StanPonomarev/stanp-opencode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 24 Wiki Activity

reduce testing
CI / verify (pull_request) Successful in 8s
Details

Browse Source
This commit is contained in:
StanPonomarev
2026-10-08 09:34:13 +02:00
parent 6f86d1af28
commit 59da616bc5
13 changed files with 299 additions and 2318 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/multi-work.test.ts
-394
View File
@@ -326,54 +326,6 @@ const request = z.object({
background: z.boolean().optional(),
});
test("Effect-native wrapper preserves name, metadata and result; moves before prompt and resumes its bound child", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
expect(f.agents.get("multi-work")?.mode).toBe("primary");
expect(f.tool.name).toBe("subagent");
expect(f.tool.options?.codemode).toBe(false);
expect(f.agents.get("coordinate")?.mode).toBe("all");
const result = yield* f.invoke();
expect(result.content).toStartWith("native result");
expect(result.content).toContain("Checkout: /worktree");
expect(result.metadata?.sessionID).toBe("ses_child1");
expect(f.order).toEqual(["create", "move-request", "moved", "prompt:/worktree"]);
expect(f.parent.location.directory).toBe("/root");
expect(bindingSchema.parse(f.storage.get(bindingKey("ses_child1"))).ready).toBe(
true,
);
const resume = yield* f.execute({
agent: "coordinate",
description: "resume",
prompt: "continue",
sessionID: "ses_child1",
background: true,
});
expect(resume.metadata?.status).toBe("running");
expect(f.herdr.creations).toBe(1);
expect(f.herdr.verified).toBe(1);
}),
),
);
});
test("local fast-lo uses native delegation without a worktree", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.execute({ agent: "fast-lo", description: "lookup", prompt: "read" });
expect(f.herdr.creations).toBe(0);
expect(f.order).toEqual(["create", "prompt:/root"]);
}),
),
);
});
test("coordinate can create and resume a root-local background child without Herdr creation or movement", async () => {
const f = fixture();
f.parent.permissions = [{ action: "herdr_worktree", resource: "*", effect: "deny" }];
@@ -496,83 +448,6 @@ test("interrupted root-local creation retains its binding and cannot be blindly
expect(f.prompts).toBe(1);
});
test("custom branch and workspace label pass through delegation", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
const result = yield* f.execute({
agent: "coordinate",
description: "Fix login timeout",
prompt: "work",
worktree: {
base: "main",
branch: "fix/login-timeout",
label: "Fix login timeout",
},
});
expect(f.herdr.createdBase).toBe("main");
expect(f.herdr.createdBranch).toBe("fix/login-timeout");
expect(f.herdr.createdLabel).toBe("Fix login timeout");
expect(result.metadata?.branch).toBe("fix/login-timeout");
}),
),
);
});
test("omitted naming retains generated branch and no explicit label", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke();
expect(f.herdr.createdBranch).toMatch(/^multi-work\/[0-9a-f-]{36}$/);
expect(f.herdr.createdLabel).toBeUndefined();
}),
),
);
});
test("rejects empty naming fields and naming on resume", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
for (const worktree of [
{ base: "main", branch: " " },
{ base: "main", label: " " },
])
expect(
(yield* Effect.exit(
f.execute({
agent: "coordinate",
description: "invalid",
prompt: "work",
worktree,
}),
))._tag,
).toBe("Failure");
yield* f.invoke();
expect(
(yield* Effect.exit(
f.execute({
agent: "coordinate",
description: "resume",
prompt: "work",
sessionID: "ses_child1",
worktree: { base: "main", branch: "fix/other" },
}),
))._tag,
).toBe("Failure");
expect(f.herdr.creations).toBe(1);
}),
),
);
});
test("root loss, session permission denial and missing destination fail before prompting", async () => {
for (const failure of ["root", "permission", "ask", "destination", "project"] as const) {
const f = fixture();
@@ -602,272 +477,3 @@ test("root loss, session permission denial and missing destination fail before p
);
}
});
test("interruption crosses the wrapper into the native executor finalizer", async () => {
const f = fixture();
f.hold();
const controller = new AbortController();
const running = Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
return yield* f.invoke();
}),
),
{ signal: controller.signal },
);
await f.entered.promise;
// entered may resolve at move request; yield until the native foreground wait is reached.
while (f.prompts === 0) await Bun.sleep(1);
controller.abort();
await expect(running).rejects.toBeDefined();
expect(f.cancelled).toBe(true);
});
test("move admission alone never admits a task; cancellation retains an unready binding", async () => {
const f = fixture();
f.delayMove();
const controller = new AbortController();
const running = Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
return yield* f.invoke();
}),
),
{ signal: controller.signal },
);
await f.entered.promise;
expect(f.prompts).toBe(0);
controller.abort();
await expect(running).rejects.toBeDefined();
expect(f.prompts).toBe(0);
expect(bindingSchema.parse(f.storage.get(bindingKey("ses_child1"))).ready).toBe(false);
});
test("rejects foreign and changed-agent resumes, non-primary multi-work and unbound coordinate calls", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke();
f.sessions.get("ses_child1")!.agent = "fast-lo";
expect(
(yield* Effect.exit(
f.execute({
agent: "coordinate",
description: "resume",
prompt: "x",
sessionID: "ses_child1",
}),
))._tag,
).toBe("Failure");
f.parent.parentID = "ses_foreign";
expect((yield* Effect.exit(f.invoke()))._tag).toBe("Failure");
f.parent.parentID = undefined;
expect(
(yield* Effect.exit(
f.invoke(undefined, { ...f.call, agent: Agent.ID.make("build") }),
))._tag,
).toBe("Failure");
expect(
(yield* Effect.exit(
f.execute({ agent: "multi-work", description: "x", prompt: "x" }),
))._tag,
).toBe("Failure");
expect(f.herdr.creations).toBe(1);
}),
),
);
});
test("command-created children require ready owned bindings and cannot bypass placement guards", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke();
const child = f.sessions.get("ses_child1")!;
const binding = bindingSchema.parse(f.storage.get(bindingKey(child.id)));
const admit = () => f.prompt({ sessionID: Session.ID.make(child.id) });
yield* admit();
f.storage.set(bindingKey(child.id), { ...binding, ready: false });
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
f.storage.set(bindingKey(child.id), binding);
child.location.directory = "/relocated";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
child.location.directory = binding.directory;
child.projectID = "foreign";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
child.projectID = binding.projectID;
f.parent.location.directory = "/elsewhere";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
f.parent.location.directory = binding.root.directory;
f.parent.agent = "build";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
f.parent.agent = "multi-work";
child.agent = "multi-work";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
child.agent = "fast-hi";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
child.agent = "fast-lo";
expect((yield* Effect.exit(admit()))._tag).toBe("Failure");
child.location.directory = f.parent.location.directory;
yield* admit();
}),
),
);
});
test("ineligible roots do not register multi-work; multi-work cannot execute shell even with session overrides", async () => {
const f = fixture();
f.herdr.eligible = false;
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
expect(f.agents.has("multi-work")).toBe(false);
const hook = f.toolHooks[0]!;
expect(
(yield* Effect.exit(hook({ ...f.call, tool: "shell", input: {} })))._tag,
).toBe("Failure");
}),
),
);
});
test("interruption during Herdr creation aborts the command and retains an inspectable attempt without prompting", async () => {
const f = fixture();
f.herdr.delayCreation = true;
const controller = new AbortController();
const running = Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
return yield* f.invoke();
}),
),
{ signal: controller.signal },
);
await f.herdr.creationStarted.promise;
controller.abort();
await expect(running).rejects.toBeDefined();
expect(f.herdr.creationAborted).toBe(true);
expect(f.prompts).toBe(0);
expect(f.storage.has(`multi-work-call:${f.call.sessionID}:${f.call.id}`)).toBe(true);
});
test("waits for asynchronous destination plugin activation before moving or prompting", async () => {
const f = fixture();
f.warmDestination();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke();
expect(f.agentReads).toBe(2);
expect(f.prompts).toBe(1);
expect(f.order).toEqual(["create", "move-request", "moved", "prompt:/worktree"]);
}),
),
);
});
test("configured build restrictions remain effective for worktree preparation", async () => {
const f = fixture();
f.agents.set("build", {
...Agent.Info.default(Agent.ID.make("build")),
permissions: [{ action: "herdr_worktree", resource: "*", effect: "deny" }],
});
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
expect((yield* Effect.exit(f.invoke()))._tag).toBe("Failure");
expect(f.herdr.creations).toBe(0);
}),
),
);
});
test("worktree resumes retain the herdr_worktree permission guard", async () => {
const f = fixture();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke();
f.parent.permissions = [
{ action: "herdr_worktree", resource: "*", effect: "deny" },
];
const resumed = yield* Effect.exit(
f.execute({
agent: "coordinate",
description: "resume",
prompt: "continue",
sessionID: "ses_child1",
}),
);
expect(resumed._tag).toBe("Failure");
expect(f.herdr.verified).toBe(0);
expect(f.prompts).toBe(1);
}),
),
);
});
test("failed initialization records the attempt and never blindly recreates on replay", async () => {
const f = fixture();
f.missingDestination();
await Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
expect((yield* Effect.exit(f.invoke()))._tag).toBe("Failure");
expect((yield* Effect.exit(f.invoke()))._tag).toBe("Failure");
expect(f.herdr.creations).toBe(1);
expect(f.prompts).toBe(0);
const record = z
.object({ child: z.string(), branch: z.string() })
.parse(f.storage.get(`multi-work-call:${f.call.sessionID}:${f.call.id}`));
expect(record.child).toBe("ses_child1");
expect(record.branch).toStartWith("multi-work/");
}),
),
);
});
test("same-child concurrent resumes are rejected while the native foreground executor is active", async () => {
const f = fixture();
f.hold();
const controller = new AbortController();
const checked = Promise.withResolvers<void>();
const running = Effect.runPromise(
Effect.scoped(
Effect.gen(function* () {
yield* f.install;
yield* f.invoke().pipe(Effect.forkScoped);
yield* Effect.promise(() => f.entered.promise);
const second = yield* Effect.exit(
f.execute({
agent: "coordinate",
description: "resume",
prompt: "continue",
sessionID: "ses_child1",
}),
);
expect(second._tag).toBe("Failure");
expect(f.herdr.creations).toBe(1);
checked.resolve();
return yield* Effect.never;
}),
),
{ signal: controller.signal },
);
await Promise.race([checked.promise, running]);
controller.abort();
await expect(running).rejects.toBeDefined();
expect(f.cancelled).toBe(true);
});