ticket-runner 0.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.ko.md +97 -0
- package/README.md +98 -0
- package/bin/ticket-runner.js +6 -0
- package/docs/templates/operator-skill.md +87 -0
- package/package.json +42 -0
- package/src/acceptance-criteria.ts +44 -0
- package/src/adapters/claude-agent-runner.ts +389 -0
- package/src/adapters/exec.ts +169 -0
- package/src/adapters/gh-tracker.ts +955 -0
- package/src/adapters/git-workspace.ts +951 -0
- package/src/adapters/repo-root.ts +20 -0
- package/src/adapters/version.ts +118 -0
- package/src/base-branch.ts +21 -0
- package/src/branch.ts +33 -0
- package/src/cli.ts +135 -0
- package/src/command-line.ts +190 -0
- package/src/config.ts +277 -0
- package/src/conventions.ts +118 -0
- package/src/criteria.ts +106 -0
- package/src/frontier.ts +36 -0
- package/src/guards.ts +143 -0
- package/src/handoff.ts +82 -0
- package/src/host.ts +116 -0
- package/src/init.ts +405 -0
- package/src/labels.ts +42 -0
- package/src/landing.ts +75 -0
- package/src/lifecycle.ts +34 -0
- package/src/lock.ts +215 -0
- package/src/note-schema.ts +58 -0
- package/src/notes.ts +433 -0
- package/src/operator-skill.ts +24 -0
- package/src/orchestrator.ts +1816 -0
- package/src/ports/agent-runner.ts +105 -0
- package/src/ports/tracker.ts +334 -0
- package/src/ports/workspace.ts +422 -0
- package/src/progress.ts +231 -0
- package/src/prompts.ts +288 -0
- package/src/readiness.ts +256 -0
- package/src/remove.ts +732 -0
- package/src/resume.ts +145 -0
- package/src/run-log.ts +85 -0
- package/src/run.ts +331 -0
- package/src/self-hosting.ts +33 -0
- package/src/stage-guard.ts +32 -0
- package/src/staleness.ts +101 -0
- package/src/start.ts +284 -0
- package/src/startup.ts +34 -0
- package/src/stop.ts +178 -0
- package/src/stranded.ts +136 -0
- package/src/templates.ts +596 -0
- package/src/title.ts +97 -0
- package/src/verdict.ts +88 -0
- package/src/version-number.ts +67 -0
- package/src/version-pr.ts +103 -0
package/src/landing.ts
ADDED
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* One Ticket's turn at the Landing: what it enters, gives up, and enters again.
|
|
3
|
+
*
|
|
4
|
+
* A turn rather than a bare pair of calls because a Ticket reaches the rebase
|
|
5
|
+
* more than once — a fix Stage sends it back — and gives the Landing up on
|
|
6
|
+
* paths that cannot know whether it ever got in. The turn remembers, so
|
|
7
|
+
* entering twice and leaving what was never entered are both nothing.
|
|
8
|
+
*/
|
|
9
|
+
export interface LandingTurn {
|
|
10
|
+
/** Wait for the Landing, and hold it until {@link leave}. */
|
|
11
|
+
enter(): Promise<void>;
|
|
12
|
+
/** Give the Landing up, so the Ticket that arrived next takes it. */
|
|
13
|
+
leave(): void;
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
/**
|
|
17
|
+
* The Landing: the stretch of a Ticket from its rebase to the pull of the Base
|
|
18
|
+
* branch after its merge, which one Ticket is in at a time (ADR-0005).
|
|
19
|
+
*
|
|
20
|
+
* A Run has one and every Ticket it drives shares it, so the Base branch cannot
|
|
21
|
+
* move between a Ticket's rebase and its merge: what CI graded is what lands.
|
|
22
|
+
* Turns are taken in arrival order — the Ticket that reaches the rebase first
|
|
23
|
+
* lands first, whatever its number — and a Ticket that leaves the stretch for a
|
|
24
|
+
* fix Stage, a hand-off or a Release gives its turn up rather than holding every
|
|
25
|
+
* other Ticket behind a session nobody is waiting on.
|
|
26
|
+
*
|
|
27
|
+
* With one Ticket at a time nothing here is ever contended: the first
|
|
28
|
+
* {@link LandingTurn.enter} of a Run resolves on the spot, and the Run makes the
|
|
29
|
+
* same calls in the same order it always did.
|
|
30
|
+
*/
|
|
31
|
+
export class Landing {
|
|
32
|
+
/** Whether a Ticket is in the Landing right now. */
|
|
33
|
+
private occupied = false;
|
|
34
|
+
|
|
35
|
+
/** What resumes each waiting Ticket, in the order they arrived. */
|
|
36
|
+
private readonly waiting: (() => void)[] = [];
|
|
37
|
+
|
|
38
|
+
turn(): LandingTurn {
|
|
39
|
+
// Whether this Ticket is the one inside, which only its own turn knows:
|
|
40
|
+
// the Landing itself counts places, not Tickets.
|
|
41
|
+
let inside = false;
|
|
42
|
+
return {
|
|
43
|
+
enter: async () => {
|
|
44
|
+
if (inside) return;
|
|
45
|
+
await this.take();
|
|
46
|
+
inside = true;
|
|
47
|
+
},
|
|
48
|
+
leave: () => {
|
|
49
|
+
if (!inside) return;
|
|
50
|
+
inside = false;
|
|
51
|
+
this.give();
|
|
52
|
+
},
|
|
53
|
+
};
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
private async take(): Promise<void> {
|
|
57
|
+
if (!this.occupied) {
|
|
58
|
+
this.occupied = true;
|
|
59
|
+
return;
|
|
60
|
+
}
|
|
61
|
+
await new Promise<void>((resume) => this.waiting.push(resume));
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
private give(): void {
|
|
65
|
+
// Handed straight to the Ticket that has waited longest rather than opened
|
|
66
|
+
// to whoever asks next: a Landing left empty for a turn of the event loop
|
|
67
|
+
// is one a Ticket arriving late could take ahead of the queue.
|
|
68
|
+
const next = this.waiting.shift();
|
|
69
|
+
if (next === undefined) {
|
|
70
|
+
this.occupied = false;
|
|
71
|
+
return;
|
|
72
|
+
}
|
|
73
|
+
next();
|
|
74
|
+
}
|
|
75
|
+
}
|
package/src/lifecycle.ts
ADDED
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Where a Ticket was when it failed. Named after the lifecycle step, not the
|
|
3
|
+
* Stage, because Checks, rebase, PR and CI are not agent sessions.
|
|
4
|
+
*/
|
|
5
|
+
export type FailurePoint =
|
|
6
|
+
| "setup"
|
|
7
|
+
| "implement"
|
|
8
|
+
| "checks"
|
|
9
|
+
| "verify"
|
|
10
|
+
| "fix"
|
|
11
|
+
| "rebase"
|
|
12
|
+
| "pr"
|
|
13
|
+
| "ci"
|
|
14
|
+
| "merge";
|
|
15
|
+
|
|
16
|
+
/**
|
|
17
|
+
* The failures a fix Stage is given a second try at, and what the fix prompt
|
|
18
|
+
* calls each of them.
|
|
19
|
+
*
|
|
20
|
+
* Every other failure ends the Ticket where it stands, because none of them is
|
|
21
|
+
* a defect in the code a fresh session could go and mend: a Stage that never
|
|
22
|
+
* came back, a Verdict with no evidence in it, a pull request whose checks
|
|
23
|
+
* timed out or never ran. A rebase conflict is on this list only once the
|
|
24
|
+
* conflict Stage has failed to resolve it, which is what makes it a defect in
|
|
25
|
+
* the branch rather than a state nobody has tried to mend yet. Uncommitted work
|
|
26
|
+
* is on it because committing it is a job for a session that can tell what
|
|
27
|
+
* belongs to the Ticket.
|
|
28
|
+
*/
|
|
29
|
+
export type FailureKind =
|
|
30
|
+
| "uncommitted-work"
|
|
31
|
+
| "failed-check"
|
|
32
|
+
| "unmet-criteria"
|
|
33
|
+
| "failed-ci"
|
|
34
|
+
| "unresolved-conflict";
|
package/src/lock.ts
ADDED
|
@@ -0,0 +1,215 @@
|
|
|
1
|
+
import { execFileSync } from "node:child_process";
|
|
2
|
+
import { readFileSync } from "node:fs";
|
|
3
|
+
import { type Host, describeHost, sameHost } from "./host.js";
|
|
4
|
+
import type { HeldLock, LockHolder } from "./ports/workspace.js";
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* One Run at a time per Target, whichever Host it is on (ADR-0008).
|
|
8
|
+
*
|
|
9
|
+
* Two Runs sharing a Target would fight over its base branch, over the same
|
|
10
|
+
* Frontier and over the same worktrees. The lock lives on the Target's GitHub
|
|
11
|
+
* repository so every Host sees it: {@link LOCK_BRANCH} always exists, and its
|
|
12
|
+
* tip's {@link LOCK_FILE} says who holds it or that nobody does. It is taken by
|
|
13
|
+
* compare-and-swap, a "held" commit pushed with a lease on the tip the taker
|
|
14
|
+
* read, and released by a "free" commit on top of that; nothing is ever
|
|
15
|
+
* deleted, which a cloud Host could not do.
|
|
16
|
+
*
|
|
17
|
+
* This module is what the lock says and what it means: the file, the commit
|
|
18
|
+
* message a human reads on GitHub, and whether a holder is still running. The
|
|
19
|
+
* git-backed Workspace does the pushing
|
|
20
|
+
* ({@link import("./ports/workspace.js").Workspace.takeRunLock} and the rest).
|
|
21
|
+
*/
|
|
22
|
+
|
|
23
|
+
/** The branch the lock lives on, under the prefix the pipeline owns. */
|
|
24
|
+
export const LOCK_BRANCH = "ticket-runner/lock";
|
|
25
|
+
|
|
26
|
+
/** The file at the top of the lock branch's tip that says who holds it. */
|
|
27
|
+
export const LOCK_FILE = "lock.json";
|
|
28
|
+
|
|
29
|
+
/** What a free lock's file says, and what a human commits to release one. */
|
|
30
|
+
export const FREE_LOCK = '{ "held": false }';
|
|
31
|
+
|
|
32
|
+
/** Whether a pid is alive, and which process it is when it is. */
|
|
33
|
+
export type ProcessCheck = { alive: false } | { alive: true; startedAt: string | undefined };
|
|
34
|
+
|
|
35
|
+
/**
|
|
36
|
+
* What a lock's holder is to a Run on `here`: still running, a process on this
|
|
37
|
+
* same Host that has gone, or a Run on another Host, whose process nothing here
|
|
38
|
+
* can see and which is therefore never presumed gone.
|
|
39
|
+
*/
|
|
40
|
+
export type HolderStanding = "running" | "abandoned" | "elsewhere";
|
|
41
|
+
|
|
42
|
+
export function holderStanding(
|
|
43
|
+
holder: LockHolder,
|
|
44
|
+
here: Host,
|
|
45
|
+
checkProcess: (pid: number) => ProcessCheck,
|
|
46
|
+
): HolderStanding {
|
|
47
|
+
if (!sameHost(holder.host, here)) return "elsewhere";
|
|
48
|
+
return holderIsCurrent(holder, checkProcess(holder.pid)) ? "running" : "abandoned";
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** The lock file for `holder`, or a free one when nobody holds the lock. */
|
|
52
|
+
export function lockFileContents(holder: LockHolder | undefined): string {
|
|
53
|
+
if (holder === undefined) return `${FREE_LOCK}\n`;
|
|
54
|
+
return `${JSON.stringify({ held: true, ...holder }, null, 2)}\n`;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/**
|
|
58
|
+
* The commit message a lock change carries, which is what GitHub shows beside
|
|
59
|
+
* the branch: who holds the Target, or that nobody does.
|
|
60
|
+
*/
|
|
61
|
+
export function lockCommitMessage(holder: LockHolder | undefined): string {
|
|
62
|
+
if (holder === undefined) return "Free";
|
|
63
|
+
return `Held by run ${holder.runId} on ${describeHost(holder.host)}: ${holder.command}`;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/**
|
|
67
|
+
* Who a lock file says holds the lock, or nobody.
|
|
68
|
+
*
|
|
69
|
+
* Only a file that says it is held, and names a Host and a process, is a
|
|
70
|
+
* holder. Anything else — `{ "held": false }`, a file a human edited to say
|
|
71
|
+
* something else, or no file at all — is a free lock, because that is how a
|
|
72
|
+
* human releases one on GitHub, and the only writers of this file are the
|
|
73
|
+
* pipeline and that human.
|
|
74
|
+
*/
|
|
75
|
+
export function readLockFile(contents: string): LockHolder | undefined {
|
|
76
|
+
let parsed: unknown;
|
|
77
|
+
try {
|
|
78
|
+
parsed = JSON.parse(contents);
|
|
79
|
+
} catch {
|
|
80
|
+
return undefined;
|
|
81
|
+
}
|
|
82
|
+
if (typeof parsed !== "object" || parsed === null) return undefined;
|
|
83
|
+
|
|
84
|
+
const record = parsed as Partial<LockHolder> & { held?: unknown };
|
|
85
|
+
const host = record.host as Partial<Host> | undefined;
|
|
86
|
+
if (record.held !== true || !Number.isInteger(record.pid)) return undefined;
|
|
87
|
+
if (host?.kind !== "workstation" && host?.kind !== "cloud") return undefined;
|
|
88
|
+
if (typeof host.id !== "string" || host.id === "") return undefined;
|
|
89
|
+
return {
|
|
90
|
+
host: { kind: host.kind, id: host.id, name: typeof host.name === "string" ? host.name : host.id },
|
|
91
|
+
pid: record.pid as number,
|
|
92
|
+
command: record.command ?? "ticket-runner",
|
|
93
|
+
runId: record.runId ?? "unknown",
|
|
94
|
+
startedAt: record.startedAt ?? "unknown",
|
|
95
|
+
...(typeof record.processStartedAt === "string"
|
|
96
|
+
? { processStartedAt: record.processStartedAt }
|
|
97
|
+
: {}),
|
|
98
|
+
};
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
/** The one line the Run that lost prints before exiting. */
|
|
102
|
+
export function lockHeldMessage({ holder, onAnotherHost }: HeldLock): string {
|
|
103
|
+
if (!onAnotherHost) {
|
|
104
|
+
return [
|
|
105
|
+
`Another ticket-runner is running on this Host: \`${holder.command}\``,
|
|
106
|
+
`as run ${holder.runId} (pid ${holder.pid}, started ${holder.startedAt}).`,
|
|
107
|
+
"Wait for it to finish, or ask it to with `ticket-runner stop`.",
|
|
108
|
+
].join(" ");
|
|
109
|
+
}
|
|
110
|
+
return [
|
|
111
|
+
`\`${holder.command}\` holds this Target as run ${holder.runId}`,
|
|
112
|
+
`on ${describeHost(holder.host)}, started ${holder.startedAt}.`,
|
|
113
|
+
releaseAdvice(),
|
|
114
|
+
].join(" ");
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* What a Run that could not give the lock up says as it ends. The lock still
|
|
119
|
+
* names it: a Run on this Host takes it over by itself, and a Run on any other
|
|
120
|
+
* waits for a human.
|
|
121
|
+
*/
|
|
122
|
+
export function unreleasedLockMessage(reason: string): string {
|
|
123
|
+
return (
|
|
124
|
+
`Could not release the Run lock: ${reason}. It still names this Run on the ` +
|
|
125
|
+
`\`${LOCK_BRANCH}\` branch. The next Run on this Host takes it over by itself; for a ` +
|
|
126
|
+
`Run on any other Host, commit a \`${LOCK_FILE}\` that reads \`${FREE_LOCK}\` to that ` +
|
|
127
|
+
"branch on GitHub, or ask an Operator to."
|
|
128
|
+
);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
/**
|
|
132
|
+
* How a lock another Host holds is given up. Nothing here can tell whether
|
|
133
|
+
* that Run is still going, so waiting comes first.
|
|
134
|
+
*/
|
|
135
|
+
function releaseAdvice(): string {
|
|
136
|
+
return (
|
|
137
|
+
"A Run on another Host is never presumed gone, so the lock stays until it is released: " +
|
|
138
|
+
"wait for that Run to finish or, if it is gone, release the lock through an Operator, " +
|
|
139
|
+
`or on GitHub by committing a free tip to the \`${LOCK_BRANCH}\` branch, a ` +
|
|
140
|
+
`\`${LOCK_FILE}\` that reads \`${FREE_LOCK}\`.`
|
|
141
|
+
);
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
/**
|
|
145
|
+
* Whether a live process check still names the lock's recorded holder.
|
|
146
|
+
*
|
|
147
|
+
* A holder with no recorded start time is a claim where the start time could
|
|
148
|
+
* not be read; a live pid is trusted alone, which is what every lock did
|
|
149
|
+
* before this. Once a start time is recorded, though, a live pid this check
|
|
150
|
+
* cannot itself read a start time for is not trusted as a match — a lock that
|
|
151
|
+
* claims an identity this check cannot verify is not verified.
|
|
152
|
+
*/
|
|
153
|
+
function holderIsCurrent(holder: LockHolder, check: ProcessCheck): boolean {
|
|
154
|
+
if (!check.alive) return false;
|
|
155
|
+
if (holder.processStartedAt === undefined) return true;
|
|
156
|
+
if (check.startedAt === undefined) return false;
|
|
157
|
+
return check.startedAt === holder.processStartedAt;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
/** Signal 0 tests for existence without delivering anything, then a start time. */
|
|
161
|
+
export function checkProcessTable(pid: number): ProcessCheck {
|
|
162
|
+
if (!processIsAlive(pid)) return { alive: false };
|
|
163
|
+
return { alive: true, startedAt: readProcessStartedAt(pid) };
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
function processIsAlive(pid: number): boolean {
|
|
167
|
+
try {
|
|
168
|
+
process.kill(pid, 0);
|
|
169
|
+
return true;
|
|
170
|
+
} catch (error) {
|
|
171
|
+
// Alive, just owned by another user.
|
|
172
|
+
return errorCode(error) === "EPERM";
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
/**
|
|
177
|
+
* A pid's start time as the operating system reports it, or `undefined` when
|
|
178
|
+
* it cannot be told — an unsupported platform (Windows has no answer here),
|
|
179
|
+
* a pid already gone by the time this reads it, or anything else this does
|
|
180
|
+
* not recognise. Callers degrade to pid-only behaviour rather than fail: this
|
|
181
|
+
* check can only add confidence, never cost a Run its lock.
|
|
182
|
+
*/
|
|
183
|
+
function readProcessStartedAt(pid: number): string | undefined {
|
|
184
|
+
try {
|
|
185
|
+
if (process.platform === "linux") return linuxStartedAt(pid);
|
|
186
|
+
if (process.platform === "darwin") return darwinStartedAt(pid);
|
|
187
|
+
return undefined;
|
|
188
|
+
} catch {
|
|
189
|
+
return undefined;
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
/**
|
|
194
|
+
* `/proc/<pid>/stat`'s 22nd field, ticks since boot the kernel itself keeps.
|
|
195
|
+
* Read past the process name in parentheses, which may itself contain a
|
|
196
|
+
* space or a closing paren, by splitting on the last one in the line.
|
|
197
|
+
*/
|
|
198
|
+
function linuxStartedAt(pid: number): string | undefined {
|
|
199
|
+
const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
|
|
200
|
+
const afterComm = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
|
|
201
|
+
// Fields after the name start at state (3rd overall), so starttime (22nd)
|
|
202
|
+
// sits at index 22 - 3 = 19 here.
|
|
203
|
+
return afterComm[19];
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
/** `ps` is the closest thing macOS has to `/proc`; `lstart` is its absolute clock. */
|
|
207
|
+
function darwinStartedAt(pid: number): string | undefined {
|
|
208
|
+
const output = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
|
|
209
|
+
const trimmed = output.trim();
|
|
210
|
+
return trimmed === "" ? undefined : trimmed;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
function errorCode(error: unknown): string | undefined {
|
|
214
|
+
return (error as NodeJS.ErrnoException | undefined)?.code;
|
|
215
|
+
}
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The `notes` list as a Stage's `--json-schema` declares it, descriptions and
|
|
3
|
+
* all.
|
|
4
|
+
*
|
|
5
|
+
* One declaration rather than one per schema, because the descriptions are what
|
|
6
|
+
* a Stage actually reads: two copies would drift, and the Stage reading the
|
|
7
|
+
* stale one would be the only place it showed.
|
|
8
|
+
*
|
|
9
|
+
* A module of its own rather than a corner of `notes.ts`, because the Verdict's
|
|
10
|
+
* schema carries this list too and `notes.ts` reaches the templates a Note is
|
|
11
|
+
* posted with, which read a Verdict. Only the shape a Stage is asked for lives
|
|
12
|
+
* here, so both schemas can share it without that cycle.
|
|
13
|
+
*
|
|
14
|
+
* `ticket` is optional on purpose: a Stage that guesses a number puts the Note
|
|
15
|
+
* on an unrelated issue, where a Stage that leaves it out gets a comment on the
|
|
16
|
+
* standing Notes issue a human reads. Not knowing is an answer.
|
|
17
|
+
*
|
|
18
|
+
* The rest are the parts nearly every Note has anyway, asked for one by one so
|
|
19
|
+
* each lands under a label of its own: a triager finds the evidence without
|
|
20
|
+
* reading the whole Note, and tells one that waits on a decision from one that
|
|
21
|
+
* only needs a Ticket by its `next`. `next` alone is optional, because a Stage
|
|
22
|
+
* that knows neither a fix nor the decision in the way has nothing to put there.
|
|
23
|
+
*/
|
|
24
|
+
export const NOTES_LIST_SCHEMA = {
|
|
25
|
+
type: "array",
|
|
26
|
+
description:
|
|
27
|
+
"Defects that belong to another Ticket, or to no Ticket yet. Empty when you found none, which is the ordinary case.",
|
|
28
|
+
items: {
|
|
29
|
+
type: "object",
|
|
30
|
+
properties: {
|
|
31
|
+
ticket: {
|
|
32
|
+
type: "number",
|
|
33
|
+
description:
|
|
34
|
+
"The issue number this belongs to. Omit it unless you are sure which one.",
|
|
35
|
+
},
|
|
36
|
+
summary: {
|
|
37
|
+
type: "string",
|
|
38
|
+
description: "One short sentence naming the defect.",
|
|
39
|
+
},
|
|
40
|
+
evidence: {
|
|
41
|
+
type: "string",
|
|
42
|
+
description:
|
|
43
|
+
"Where the defect is and what shows it is real: what you ran or read, what you expected and what came back.",
|
|
44
|
+
},
|
|
45
|
+
impact: {
|
|
46
|
+
type: "string",
|
|
47
|
+
description: "What breaks, and for whom.",
|
|
48
|
+
},
|
|
49
|
+
next: {
|
|
50
|
+
type: "string",
|
|
51
|
+
description:
|
|
52
|
+
"The fix, or the decision a human has to take before anyone can fix it. Leave it out when there is neither.",
|
|
53
|
+
},
|
|
54
|
+
},
|
|
55
|
+
required: ["summary", "evidence", "impact"],
|
|
56
|
+
additionalProperties: false,
|
|
57
|
+
},
|
|
58
|
+
} as const;
|