@maycombhq/sdk 2.0.0-beta.22 → 2.0.0-beta.23
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/npm/core/api.d.ts +2693 -336
- package/npm/core/facts-join.d.ts +73 -1
- package/npm/core/fs.d.ts +8 -0
- package/npm/core/index.d.ts +4 -0
- package/npm/core/kept-files.d.ts +17 -0
- package/npm/core/light.d.ts +2 -0
- package/npm/core/log.d.ts +2 -0
- package/npm/core/manifest-edit.d.ts +21 -3
- package/npm/core/metarepo.d.ts +8 -0
- package/npm/core/orgpack-defaults.d.ts +3 -1
- package/npm/core/printer.d.ts +4 -0
- package/npm/core/question-owners.d.ts +4 -0
- package/npm/core/question-roles.d.ts +64 -4
- package/npm/core/questions.d.ts +14 -3
- package/npm/core/roles-migrate.d.ts +4 -3
- package/npm/core/run-log.d.ts +165 -0
- package/npm/core/schema/fact-corrections.d.ts +5 -0
- package/npm/core/schema/orgpack.d.ts +22 -6
- package/npm/core/schema/question.d.ts +55 -2
- package/npm/core/schema/scan-verify.d.ts +35 -0
- package/npm/core/setup-edit.d.ts +107 -0
- package/npm/index.js +1043 -43
- package/package.json +1 -1
package/npm/core/api.d.ts
CHANGED
|
@@ -313,10 +313,134 @@ import { z } from "zod";
|
|
|
313
313
|
* the credential store (422). POST /api/workspace/sync and /api/reconcile answer 409 while one of
|
|
314
314
|
* their kind runs; GET /api/past-changes?change= and /api/changes/{changeId}/cockpit answer 400
|
|
315
315
|
* for a change id that isn't one, and /api/view/{name} 404 for a name that isn't a view.
|
|
316
|
+
* 3.1.0 (review round 50, ADR 0186 addendum: nothing the assistant writes stands for the person).
|
|
317
|
+
* POST /api/runs, and in model mode POST /api/changes/{changeId}/runs and .../tasks/run-ready,
|
|
318
|
+
* answer 403 unless runtime.yaml sends the model's key where the person last confirmed it (a
|
|
319
|
+
* confirmed save or Test in the AI settings, or a step they ran in their own terminal; kept
|
|
320
|
+
* outside the metarepo), or, with none confirmed yet, to a built-in provider's own address.
|
|
321
|
+
* POST /api/settings/ai/test needs `ai-test` whenever the address isn't the confirmed one, even
|
|
322
|
+
* when committed. POST /api/me/digest's `digest-send` target is the channel it posts to, read
|
|
323
|
+
* at the send (GET /api/me gives it as notify.to); `me` is refused. POST /api/runs/{runId}/done
|
|
324
|
+
* runs only the resume Atticus kept for a step the app prepared (never a file in .runs/), and
|
|
325
|
+
* only that step's own. POST /api/changes/{changeId}/workspace and .../runs answer 409 while a
|
|
326
|
+
* sync of a repo's base clone runs elsewhere. Not additive for the digest's target only: the
|
|
327
|
+
* app's page is updated with it.
|
|
328
|
+
* 3.2.0 (ADR 0187, the Console): everything Atticus is doing or did lately on this metarepo, live,
|
|
329
|
+
* wherever it was started. GET /api/activity lists the app's jobs, a Copilot run, the commands run
|
|
330
|
+
* in a terminal, an editor or a Copilot session (from .atticus/logs/running/), and the hand-off
|
|
331
|
+
* runs that wait for an assistant, newest first; GET /api/activity/{id}/lines?from=n gives one's
|
|
332
|
+
* printed lines from a line on. The live events `activity.changed` and `activity.lines` carry the
|
|
333
|
+
* same. Stop goes through the existing routes (POST /api/jobs/{jobId}/cancel, POST
|
|
334
|
+
* /api/copilot-runs/{runId}/stop); a terminal's run stops in its terminal. A Job gains `title`
|
|
335
|
+
* and the kind `work` (a request the page waits on, run as a job so the Console shows it: the
|
|
336
|
+
* critic, a wiki's sync, a step run, a run's Done; their answers are unchanged). Additive only.
|
|
337
|
+
* 3.3.0 (beta.23, Home loads fast): GET /api/setup no longer waits for the machine's checks:
|
|
338
|
+
* until they finish, its `machine` step has `checking: true` (and `done: false`), and GET
|
|
339
|
+
* /api/doctor answers when they do; `?machine=wait` waits for them as before. Additive only.
|
|
340
|
+
* 3.4.0 (app-only audit: tasks, release, archive). A Task gains `unmerged` (its branch's commits
|
|
341
|
+
* the change branch here hasn't), `decision` (a person let its work go, with why) and
|
|
342
|
+
* `repoBuilds`; POST .../tasks/{taskId}/done answers 409 for a task whose branch has commits the
|
|
343
|
+
* change branch hasn't, here or on the Git host, unless the body gives a `reason`; POST
|
|
344
|
+
* .../tasks/{taskId}/build is Build and raise PR (`raise` needs `task-pr`). Build ready, go/no-go
|
|
345
|
+
* and POST .../release-prs hold while a task branch's work isn't in the change branch.
|
|
346
|
+
* ChangeDetail's handoff gains `unpushed` and `branch` (its push failed; the branch is kept
|
|
347
|
+
* here), and POST /api/changes/{changeId}/handoff/push is Push again (`handoff`).
|
|
348
|
+
* POST /api/propose/upstream sets the upstream Bring in what merged offers, as a local job.
|
|
349
|
+
* POST /api/scan asks host questions only for repos with facts on file unless `askAll`, and
|
|
350
|
+
* its job's result says what the readers added, changed and removed (`added`, `changed`,
|
|
351
|
+
* `removed`) and how many questions it asked (`questions`).
|
|
352
|
+
* 3.5.0 (ADR 0188, a button for every step in the daily path): the local steps the app's pages
|
|
353
|
+
* named as commands, as the person's click. POST /api/facts/apply-all (`atticus verify --all
|
|
354
|
+
* --write`), POST /api/estate/join, POST /api/knowledge/sources/sync (every wiki) and POST
|
|
355
|
+
* /api/workspace/prune (`{ change? }`; uncommitted worktrees kept) run as local jobs (409 while
|
|
356
|
+
* another local step runs); GET /api/changes/{changeId}/tasks/{taskId}/context gives the task's
|
|
357
|
+
* context as markdown; PUT /api/history/recording (`{ on }`) is `atticus history on|off`. POST
|
|
358
|
+
* /api/runs and /api/runs/handoff take `map <repo>` and `change small <change>`, and `--force`
|
|
359
|
+
* on `plan stories` only (Draft the stories again); a read's Done (POST /api/runs/{runId}/done)
|
|
360
|
+
* runs `verify <repo> --write` after its last batch and says so in `applied`. Propose's `work`
|
|
361
|
+
* scope also takes a change's target-flows/ and knowledge.yaml; an answered question a read
|
|
362
|
+
* raised (rerun `atticus map <repo>`) counts in `applyFirst`. Additive only.
|
|
363
|
+
* 3.6.0 (ADR 0189, a stage is one conversation). GET /api/changes/{changeId}/stages/{stage}/thread
|
|
364
|
+
* is a stage's thread (proposal, feature, architecture, stories or small): the prompts handed to
|
|
365
|
+
* the person's assistant, its answers and what their checks said, the critic's findings, the
|
|
366
|
+
* stage's questions, the person's replies and corrections, and the questions that couldn't be
|
|
367
|
+
* kept, in order (StageThreadView). POST .../thread is a person's reply (`reply`, which the
|
|
368
|
+
* stage's next round reads as their answer), a comment on a finding (`finding`), or keeping a
|
|
369
|
+
* dropped question anyway (`keep`). The server checks a waiting hand-off's answer once its file
|
|
370
|
+
* is complete, as Done does (Done stays), and says so in the thread. A sketch stroke may be
|
|
371
|
+
* `retire` (a component taken away). Additive only.
|
|
372
|
+
* 3.7.0 (ADR 0190, set up from the app: "Edit, then Propose"). GET /api/health gains `metarepo`.
|
|
373
|
+
* GET/POST /api/setup/metarepo create the metarepo in the app's folder with init's code (the
|
|
374
|
+
* Git host manual, with the metarepo's id when known), POST /api/setup/open starts the app for
|
|
375
|
+
* another folder. POST /api/setup/repos/plan reads pasted clone URLs or a folder of clones
|
|
376
|
+
* (repos discover's code) into the repos to add, and POST /api/setup/repos writes them to the
|
|
377
|
+
* manifest. POST /api/repos/{repoId}/type/detect and PUT /api/repos/{repoId}/type detect and set
|
|
378
|
+
* a repo's type. GET /api/setup/adapters and PUT /api/setup/adapters/{kind} set runtime.yaml's
|
|
379
|
+
* outside systems; GET/PUT /api/setup/file is the raw editor of an org-pack file; POST
|
|
380
|
+
* /api/setup/patterns and /api/setup/sources add an integration pattern and a wiki. Every write
|
|
381
|
+
* takes `preview` (the lines it would change, nothing written) and answers a FileEditView; the
|
|
382
|
+
* files are then proposed for review as before. PUT /api/settings/ai's `decide` lifts a
|
|
383
|
+
* runtime.yaml of any older version to 4 (upgrade's runtime-v4 step), not only a version 3
|
|
384
|
+
* one. Additive only.
|
|
385
|
+
* 3.8.0 (ADR 0191, roles and the BA): a change goes product owner → architect → business analyst →
|
|
386
|
+
* tech lead. A question carries what it asks (`asks`, question version 6) and POST
|
|
387
|
+
* /api/questions/{id}/route moves it to another role (`routed`); GET /api/questions' `about`
|
|
388
|
+
* gains `asks`. GET /api/findings gives each finding's `asks` and takes `asks=` to filter. GET
|
|
389
|
+
* /api/changes/{changeId}/owners/suggested suggests owners from roles.yaml (version 3: a team's
|
|
390
|
+
* `roles`, the file's `defaults`). The cockpit's `waitsOn` names who the change waits on; a
|
|
391
|
+
* hand-off names the next role's owners as reviewers and tells them through the notify adapter.
|
|
392
|
+
* GET and POST /api/changes/{changeId}/work-items put the plan's feature, stories and tasks in
|
|
393
|
+
* the work tracker (manual: a step each; live: `work-items`). POST
|
|
394
|
+
* /api/owner-questions/{id}/send sends an owner question (`owner-ask`; a critic gap asked with
|
|
395
|
+
* Ask is one of them). GET /api/ask answers from the organisation's knowledge too
|
|
396
|
+
* (`knowledge`); GET /api/knowledge/search reads inputs/ when its source has no snapshot; GET
|
|
397
|
+
* /api/knowledge/passage opens a suggested section inline; a change's knowledge item carries
|
|
398
|
+
* `passage`. GET, POST /api/changes/{changeId}/stories/shape and POST
|
|
399
|
+
* .../stories/shape/{entryId}/remove are the business analyst's shaping of the stories.
|
|
400
|
+
* Additive only.
|
|
401
|
+
* 3.9.0 (ADR 0190, set up from the app, a review's fixes): GET /api/setup/adapters gains
|
|
402
|
+
* `sha256` (runtime.yaml's, as read) and PUT /api/setup/adapters/{kind} takes it back as
|
|
403
|
+
* `baseSha256`, so a form read before another edit is refused (409) rather than overwriting it.
|
|
404
|
+
* The raw editor (GET/PUT /api/setup/file) refuses a name Atticus reads written in another case
|
|
405
|
+
* (`Runtime.yaml`, 422) and a manifest listing a repo id another profile lists (422); a
|
|
406
|
+
* runtime.yaml that doesn't parse can be saved over, and new content that doesn't read is 422,
|
|
407
|
+
* never 500. POST /api/setup/sources refuses a location with a user name or password in it
|
|
408
|
+
* (422) and a sources.yaml changed meanwhile (409). POST /api/setup/repos/plan for a folder,
|
|
409
|
+
* with several platforms and none given, answers the platforms to choose from and reads
|
|
410
|
+
* nothing. Additive only.
|
|
411
|
+
* Home (beta.23 review): GET /api/changes gives each change the viewer's `yourRoles`
|
|
412
|
+
* (read from its owners as the questions' `yourRoles` are), so Home knows them for every change
|
|
413
|
+
* in flight. A `file.changed` live event says whether it can change the catalog (`catalog`),
|
|
414
|
+
* by the folders the org pack's layout names. Additive only.
|
|
415
|
+
* An editor panel (beta.23 review): POST /api/runs/{runId}/done takes
|
|
416
|
+
* `{ job: true }` and POST /api/changes/{changeId}/work-items takes `job: true`: the work runs
|
|
417
|
+
* as a job (ADR 0187, so the Console shows it), the answer is 202 JobAccepted at once, and the
|
|
418
|
+
* job's result carries the answer the call gives without it (`answer`) or its problem
|
|
419
|
+
* (`problem`). The refusals a request can know at once (409, 400, a missing confirmation) still
|
|
420
|
+
* come as the answer. Without `job` nothing changes. GET /api/activity's entries gain `rev`,
|
|
421
|
+
* the version of an entry's lines when they are rewritten rather than added to (a hand-off
|
|
422
|
+
* run's, once Done ran): the page reads them again when it changes. Additive only.
|
|
423
|
+
* Every daily step (ADR 0188, beta.23 review): nobody is left at a command to type. A step that needs a
|
|
424
|
+
* repo's base clone this machine doesn't have (Apply, Apply to every repo, the read of a repo)
|
|
425
|
+
* says what the app offers next: its job's result, or its 422 problem, carries `next: { step:
|
|
426
|
+
* "sync", repos }`, which the app shows as Sync the repos. POST /api/workspace/sync's result
|
|
427
|
+
* gives `code` and every line, its errors too. A local job's lines are in the app's words. POST
|
|
428
|
+
* /api/runs for `map <repo>` runs `verify <repo> --write` after a read that kept every fact
|
|
429
|
+
* (`applied`), as a read's Done does. A Done's resume runs as a local job (one local step at a
|
|
430
|
+
* time). Propose for review fails when its branch wasn't pushed. Additive only.
|
|
316
431
|
*/
|
|
317
|
-
export declare const API_VERSION = "3.
|
|
432
|
+
export declare const API_VERSION = "3.9.0";
|
|
318
433
|
export declare const DEFAULT_PORT = 4321;
|
|
319
434
|
/** RFC 9457 problem details, used for every error. */
|
|
435
|
+
/**
|
|
436
|
+
* 3.9.0 (ADR 0188): the step the app offers after a refusal or a failed job: Sync the repos
|
|
437
|
+
* whose base clone this machine doesn't have.
|
|
438
|
+
*/
|
|
439
|
+
export declare const NextStep: z.ZodObject<{
|
|
440
|
+
step: z.ZodLiteral<"sync">;
|
|
441
|
+
repos: z.ZodArray<z.ZodString>;
|
|
442
|
+
}, z.core.$strip>;
|
|
443
|
+
export type NextStepT = z.infer<typeof NextStep>;
|
|
320
444
|
export declare const Problem: z.ZodObject<{
|
|
321
445
|
type: z.ZodString;
|
|
322
446
|
title: z.ZodString;
|
|
@@ -330,6 +454,10 @@ export declare const Problem: z.ZodObject<{
|
|
|
330
454
|
role: z.ZodString;
|
|
331
455
|
names: z.ZodArray<z.ZodString>;
|
|
332
456
|
}, z.core.$strip>>;
|
|
457
|
+
next: z.ZodOptional<z.ZodObject<{
|
|
458
|
+
step: z.ZodLiteral<"sync">;
|
|
459
|
+
repos: z.ZodArray<z.ZodString>;
|
|
460
|
+
}, z.core.$strip>>;
|
|
333
461
|
}, z.core.$strip>;
|
|
334
462
|
export declare const CatalogRecord: z.ZodUnion<[z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, ...z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]]>;
|
|
335
463
|
export declare const RecordPage: z.ZodObject<{
|
|
@@ -1333,6 +1461,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1333
1461
|
scan: "scan";
|
|
1334
1462
|
reconcile: "reconcile";
|
|
1335
1463
|
intake: "intake";
|
|
1464
|
+
work: "work";
|
|
1336
1465
|
}>;
|
|
1337
1466
|
state: z.ZodEnum<{
|
|
1338
1467
|
done: "done";
|
|
@@ -1346,6 +1475,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1346
1475
|
total: z.ZodNumber;
|
|
1347
1476
|
message: z.ZodString;
|
|
1348
1477
|
}, z.core.$strip>;
|
|
1478
|
+
title: z.ZodOptional<z.ZodString>;
|
|
1349
1479
|
startedAt: z.ZodString;
|
|
1350
1480
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
1351
1481
|
errors: z.ZodArray<z.ZodString>;
|
|
@@ -1419,6 +1549,12 @@ export declare const ChangeSummary: z.ZodObject<{
|
|
|
1419
1549
|
}, z.core.$strip>;
|
|
1420
1550
|
updatedAt: z.ZodString;
|
|
1421
1551
|
fastPath: z.ZodOptional<z.ZodBoolean>;
|
|
1552
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1553
|
+
product: "product";
|
|
1554
|
+
architecture: "architecture";
|
|
1555
|
+
delivery: "delivery";
|
|
1556
|
+
analysis: "analysis";
|
|
1557
|
+
}>>>;
|
|
1422
1558
|
}, z.core.$strip>;
|
|
1423
1559
|
export declare const ChangeDetail: z.ZodObject<{
|
|
1424
1560
|
id: z.ZodString;
|
|
@@ -1446,6 +1582,12 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1446
1582
|
}, z.core.$strip>;
|
|
1447
1583
|
updatedAt: z.ZodString;
|
|
1448
1584
|
fastPath: z.ZodOptional<z.ZodBoolean>;
|
|
1585
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1586
|
+
product: "product";
|
|
1587
|
+
architecture: "architecture";
|
|
1588
|
+
delivery: "delivery";
|
|
1589
|
+
analysis: "analysis";
|
|
1590
|
+
}>>>;
|
|
1449
1591
|
notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1450
1592
|
owners: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
|
|
1451
1593
|
artifacts: z.ZodArray<z.ZodObject<{
|
|
@@ -1524,6 +1666,8 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1524
1666
|
merged: "merged";
|
|
1525
1667
|
closed: "closed";
|
|
1526
1668
|
}>;
|
|
1669
|
+
unpushed: z.ZodOptional<z.ZodBoolean>;
|
|
1670
|
+
branch: z.ZodOptional<z.ZodString>;
|
|
1527
1671
|
}, z.core.$strip>>;
|
|
1528
1672
|
}, z.core.$strip>;
|
|
1529
1673
|
export declare const ArtifactContent: z.ZodObject<{
|
|
@@ -1578,6 +1722,16 @@ export declare const Task: z.ZodObject<{
|
|
|
1578
1722
|
tasks: z.ZodArray<z.ZodString>;
|
|
1579
1723
|
sameRepo: z.ZodArray<z.ZodString>;
|
|
1580
1724
|
}, z.core.$strip>>;
|
|
1725
|
+
unmerged: z.ZodOptional<z.ZodObject<{
|
|
1726
|
+
commits: z.ZodNumber;
|
|
1727
|
+
branch: z.ZodString;
|
|
1728
|
+
}, z.core.$strip>>;
|
|
1729
|
+
decision: z.ZodOptional<z.ZodObject<{
|
|
1730
|
+
by: z.ZodString;
|
|
1731
|
+
at: z.ZodString;
|
|
1732
|
+
reason: z.ZodString;
|
|
1733
|
+
}, z.core.$strip>>;
|
|
1734
|
+
repoBuilds: z.ZodOptional<z.ZodBoolean>;
|
|
1581
1735
|
}, z.core.$strip>;
|
|
1582
1736
|
export type TaskT = z.infer<typeof Task>;
|
|
1583
1737
|
export declare const RunView: z.ZodObject<{
|
|
@@ -1811,6 +1965,14 @@ export declare const StartStepRequest: z.ZodObject<{
|
|
|
1811
1965
|
args: z.ZodArray<z.ZodString>;
|
|
1812
1966
|
}, z.core.$strip>;
|
|
1813
1967
|
/** 2.67.0: what Done did: the run, what it printed, and the step's next run when it offers one. */
|
|
1968
|
+
/**
|
|
1969
|
+
* 3.9.0 (review of beta.23): Done's body. `job: true` runs it as a job: 202 and the job's id at
|
|
1970
|
+
* once, the job's result `answer` the RunDoneView (or `problem`, refused), so a panel's request
|
|
1971
|
+
* never outlasts the build and commit a task run's Done makes.
|
|
1972
|
+
*/
|
|
1973
|
+
export declare const RunDoneRequest: z.ZodObject<{
|
|
1974
|
+
job: z.ZodOptional<z.ZodBoolean>;
|
|
1975
|
+
}, z.core.$strict>;
|
|
1814
1976
|
export declare const RunDoneView: z.ZodObject<{
|
|
1815
1977
|
schemaVersion: z.ZodLiteral<6>;
|
|
1816
1978
|
runId: z.ZodString;
|
|
@@ -1922,7 +2084,23 @@ export declare const RunDoneView: z.ZodObject<{
|
|
|
1922
2084
|
}, z.core.$strip>>;
|
|
1923
2085
|
lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1924
2086
|
next: z.ZodOptional<z.ZodString>;
|
|
2087
|
+
applied: z.ZodOptional<z.ZodString>;
|
|
1925
2088
|
}, z.core.$strict>;
|
|
2089
|
+
/** 3.5.0 (ADR 0188): a task's context, as `atticus task context --markdown` prints it. */
|
|
2090
|
+
export declare const TaskContextView: z.ZodObject<{
|
|
2091
|
+
markdown: z.ZodString;
|
|
2092
|
+
}, z.core.$strip>;
|
|
2093
|
+
/** 3.5.0 (ADR 0188): this machine's prompt history recording, on or off. */
|
|
2094
|
+
export declare const HistoryRecordingRequest: z.ZodObject<{
|
|
2095
|
+
on: z.ZodBoolean;
|
|
2096
|
+
}, z.core.$strip>;
|
|
2097
|
+
export declare const HistoryRecordingView: z.ZodObject<{
|
|
2098
|
+
on: z.ZodBoolean;
|
|
2099
|
+
}, z.core.$strip>;
|
|
2100
|
+
/** 3.5.0 (ADR 0188): the worktrees cleaned up: one change's, or every change's when left out. */
|
|
2101
|
+
export declare const PruneRequest: z.ZodObject<{
|
|
2102
|
+
change: z.ZodOptional<z.ZodString>;
|
|
2103
|
+
}, z.core.$strip>;
|
|
1926
2104
|
/** 2.66.0 (UX review): the step prepared for the person's own assistant, and its run. */
|
|
1927
2105
|
export declare const PreparedStepView: z.ZodObject<{
|
|
1928
2106
|
runId: z.ZodOptional<z.ZodString>;
|
|
@@ -3036,6 +3214,15 @@ export declare const ChangeKnowledgeItem: z.ZodObject<{
|
|
|
3036
3214
|
team: "team";
|
|
3037
3215
|
reference: "reference";
|
|
3038
3216
|
}>>;
|
|
3217
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3218
|
+
source: z.ZodString;
|
|
3219
|
+
page: z.ZodString;
|
|
3220
|
+
path: z.ZodString;
|
|
3221
|
+
heading: z.ZodString;
|
|
3222
|
+
line: z.ZodNumber;
|
|
3223
|
+
text: z.ZodString;
|
|
3224
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3225
|
+
}, z.core.$strip>>;
|
|
3039
3226
|
}, z.core.$strip>;
|
|
3040
3227
|
/**
|
|
3041
3228
|
* 2.26.0 (ADR 0124 addendum B-task-knowledge): pages that disagree about a knowledge item, what
|
|
@@ -3123,6 +3310,15 @@ export declare const ChangeKnowledgeView: z.ZodObject<{
|
|
|
3123
3310
|
team: "team";
|
|
3124
3311
|
reference: "reference";
|
|
3125
3312
|
}>>;
|
|
3313
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3314
|
+
source: z.ZodString;
|
|
3315
|
+
page: z.ZodString;
|
|
3316
|
+
path: z.ZodString;
|
|
3317
|
+
heading: z.ZodString;
|
|
3318
|
+
line: z.ZodNumber;
|
|
3319
|
+
text: z.ZodString;
|
|
3320
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3321
|
+
}, z.core.$strip>>;
|
|
3126
3322
|
}, z.core.$strip>>;
|
|
3127
3323
|
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3128
3324
|
id: z.ZodString;
|
|
@@ -3219,6 +3415,15 @@ export declare const SetChangeKnowledgeResult: z.ZodObject<{
|
|
|
3219
3415
|
team: "team";
|
|
3220
3416
|
reference: "reference";
|
|
3221
3417
|
}>>;
|
|
3418
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3419
|
+
source: z.ZodString;
|
|
3420
|
+
page: z.ZodString;
|
|
3421
|
+
path: z.ZodString;
|
|
3422
|
+
heading: z.ZodString;
|
|
3423
|
+
line: z.ZodNumber;
|
|
3424
|
+
text: z.ZodString;
|
|
3425
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3426
|
+
}, z.core.$strip>>;
|
|
3222
3427
|
}, z.core.$strip>>;
|
|
3223
3428
|
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3224
3429
|
id: z.ZodString;
|
|
@@ -4856,7 +5061,7 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4856
5061
|
}, z.core.$strip>>;
|
|
4857
5062
|
}, z.core.$strip>>;
|
|
4858
5063
|
questions: z.ZodArray<z.ZodObject<{
|
|
4859
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
5064
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
4860
5065
|
id: z.ZodString;
|
|
4861
5066
|
askedBy: z.ZodObject<{
|
|
4862
5067
|
step: z.ZodString;
|
|
@@ -4892,6 +5097,21 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4892
5097
|
delivery: "delivery";
|
|
4893
5098
|
analysis: "analysis";
|
|
4894
5099
|
}>>;
|
|
5100
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
5101
|
+
business: "business";
|
|
5102
|
+
delivery: "delivery";
|
|
5103
|
+
design: "design";
|
|
5104
|
+
}>>;
|
|
5105
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
5106
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
5107
|
+
product: "product";
|
|
5108
|
+
architecture: "architecture";
|
|
5109
|
+
delivery: "delivery";
|
|
5110
|
+
analysis: "analysis";
|
|
5111
|
+
}>>;
|
|
5112
|
+
by: z.ZodString;
|
|
5113
|
+
at: z.ZodISODateTime;
|
|
5114
|
+
}, z.core.$strict>>;
|
|
4895
5115
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
4896
5116
|
finding: z.ZodOptional<z.ZodObject<{
|
|
4897
5117
|
change: z.ZodString;
|
|
@@ -5065,167 +5285,1436 @@ export declare const StageCommentResult: z.ZodObject<{
|
|
|
5065
5285
|
}, z.core.$strip>;
|
|
5066
5286
|
}, z.core.$strip>;
|
|
5067
5287
|
export type StageReviewViewT = z.infer<typeof StageReviewView>;
|
|
5068
|
-
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
5069
|
-
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
5070
5288
|
/**
|
|
5071
|
-
*
|
|
5072
|
-
*
|
|
5073
|
-
*
|
|
5074
|
-
*
|
|
5075
|
-
*
|
|
5076
|
-
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
5077
|
-
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
5078
|
-
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
5079
|
-
* the draft changed for it. Kept on file either way.
|
|
5289
|
+
* 3.5.0 (ADR 0189): a stage of a change as one conversation, assembled from the files that hold
|
|
5290
|
+
* it (the runs, the stage's loop file, the critic's rounds, the questions, the corrections). The
|
|
5291
|
+
* thread is a view and the place to reply: the AI still runs in the person's editor (a hand-off),
|
|
5292
|
+
* unattended Copilot or a server model. Items are in order; a prompt's sizes, model and file
|
|
5293
|
+
* paths are its `details`, for a Details disclosure.
|
|
5080
5294
|
*/
|
|
5081
|
-
export declare const
|
|
5082
|
-
export declare const
|
|
5295
|
+
export declare const THREAD_STAGES: readonly ["proposal", "feature", "architecture", "stories", "small"];
|
|
5296
|
+
export declare const ThreadStage: z.ZodEnum<{
|
|
5297
|
+
small: "small";
|
|
5083
5298
|
architecture: "architecture";
|
|
5299
|
+
proposal: "proposal";
|
|
5084
5300
|
stories: "stories";
|
|
5085
|
-
tasks: "tasks";
|
|
5086
5301
|
feature: "feature";
|
|
5087
5302
|
}>;
|
|
5088
|
-
export declare const
|
|
5089
|
-
|
|
5090
|
-
|
|
5091
|
-
|
|
5092
|
-
|
|
5093
|
-
|
|
5094
|
-
|
|
5095
|
-
|
|
5096
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5097
|
-
}, z.core.$strip>;
|
|
5098
|
-
export declare const DraftItemView: z.ZodObject<{
|
|
5099
|
-
id: z.ZodString;
|
|
5100
|
-
label: z.ZodString;
|
|
5101
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5102
|
-
}, z.core.$strip>;
|
|
5103
|
-
export declare const DraftFileView: z.ZodObject<{
|
|
5104
|
-
file: z.ZodString;
|
|
5105
|
-
path: z.ZodString;
|
|
5106
|
-
stage: z.ZodString;
|
|
5107
|
-
drafted: z.ZodOptional<z.ZodObject<{
|
|
5108
|
-
by: z.ZodEnum<{
|
|
5109
|
-
ai: "ai";
|
|
5110
|
-
person: "person";
|
|
5111
|
-
}>;
|
|
5112
|
-
stage: z.ZodOptional<z.ZodString>;
|
|
5113
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5114
|
-
who: z.ZodOptional<z.ZodString>;
|
|
5115
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5116
|
-
}, z.core.$strip>>;
|
|
5117
|
-
items: z.ZodArray<z.ZodObject<{
|
|
5118
|
-
id: z.ZodString;
|
|
5119
|
-
label: z.ZodString;
|
|
5120
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5121
|
-
}, z.core.$strip>>;
|
|
5303
|
+
export declare const ThreadRunDetails: z.ZodObject<{
|
|
5304
|
+
agent: z.ZodString;
|
|
5305
|
+
runtime: z.ZodString;
|
|
5306
|
+
promptPath: z.ZodString;
|
|
5307
|
+
output: z.ZodOptional<z.ZodString>;
|
|
5308
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
5309
|
+
model: z.ZodOptional<z.ZodString>;
|
|
5310
|
+
attempt: z.ZodNumber;
|
|
5122
5311
|
}, z.core.$strip>;
|
|
5123
|
-
export declare const
|
|
5124
|
-
|
|
5125
|
-
stage: z.ZodString;
|
|
5126
|
-
file: z.ZodString;
|
|
5127
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5128
|
-
label: z.ZodString;
|
|
5129
|
-
text: z.ZodString;
|
|
5130
|
-
scope: z.ZodEnum<{
|
|
5131
|
-
one: "one";
|
|
5132
|
-
similar: "similar";
|
|
5133
|
-
}>;
|
|
5134
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5135
|
-
by: z.ZodString;
|
|
5312
|
+
export declare const ThreadItem: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
5313
|
+
kind: z.ZodLiteral<"prompt">;
|
|
5136
5314
|
at: z.ZodString;
|
|
5315
|
+
runId: z.ZodString;
|
|
5316
|
+
who: z.ZodEnum<{
|
|
5317
|
+
critic: "critic";
|
|
5318
|
+
drafter: "drafter";
|
|
5319
|
+
}>;
|
|
5320
|
+
prompt: z.ZodString;
|
|
5137
5321
|
state: z.ZodEnum<{
|
|
5138
|
-
|
|
5139
|
-
|
|
5322
|
+
failed: "failed";
|
|
5323
|
+
prepared: "prepared";
|
|
5140
5324
|
waiting: "waiting";
|
|
5325
|
+
produced: "produced";
|
|
5326
|
+
validated: "validated";
|
|
5327
|
+
cancelled: "cancelled";
|
|
5141
5328
|
}>;
|
|
5142
|
-
|
|
5143
|
-
|
|
5144
|
-
|
|
5145
|
-
|
|
5146
|
-
|
|
5147
|
-
|
|
5148
|
-
|
|
5149
|
-
|
|
5150
|
-
|
|
5151
|
-
|
|
5152
|
-
|
|
5153
|
-
|
|
5329
|
+
details: z.ZodObject<{
|
|
5330
|
+
agent: z.ZodString;
|
|
5331
|
+
runtime: z.ZodString;
|
|
5332
|
+
promptPath: z.ZodString;
|
|
5333
|
+
output: z.ZodOptional<z.ZodString>;
|
|
5334
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
5335
|
+
model: z.ZodOptional<z.ZodString>;
|
|
5336
|
+
attempt: z.ZodNumber;
|
|
5337
|
+
}, z.core.$strip>;
|
|
5338
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5339
|
+
kind: z.ZodLiteral<"answer">;
|
|
5340
|
+
at: z.ZodString;
|
|
5341
|
+
runId: z.ZodString;
|
|
5342
|
+
who: z.ZodEnum<{
|
|
5343
|
+
critic: "critic";
|
|
5344
|
+
drafter: "drafter";
|
|
5154
5345
|
}>;
|
|
5155
|
-
|
|
5156
|
-
|
|
5157
|
-
|
|
5158
|
-
|
|
5159
|
-
|
|
5160
|
-
|
|
5161
|
-
|
|
5162
|
-
|
|
5163
|
-
|
|
5164
|
-
|
|
5165
|
-
|
|
5166
|
-
|
|
5167
|
-
|
|
5168
|
-
|
|
5169
|
-
|
|
5346
|
+
checked: z.ZodEnum<{
|
|
5347
|
+
failed: "failed";
|
|
5348
|
+
passed: "passed";
|
|
5349
|
+
checking: "checking";
|
|
5350
|
+
}>;
|
|
5351
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
5352
|
+
person: "person";
|
|
5353
|
+
app: "app";
|
|
5354
|
+
}>>;
|
|
5355
|
+
summary: z.ZodArray<z.ZodString>;
|
|
5356
|
+
problems: z.ZodArray<z.ZodString>;
|
|
5357
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5358
|
+
kind: z.ZodLiteral<"changed">;
|
|
5359
|
+
at: z.ZodString;
|
|
5360
|
+
files: z.ZodArray<z.ZodString>;
|
|
5361
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5362
|
+
kind: z.ZodLiteral<"finding">;
|
|
5363
|
+
at: z.ZodString;
|
|
5364
|
+
view: z.ZodObject<{
|
|
5365
|
+
finding: z.ZodObject<{
|
|
5366
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
5170
5367
|
id: z.ZodString;
|
|
5171
|
-
|
|
5172
|
-
|
|
5173
|
-
|
|
5174
|
-
|
|
5175
|
-
|
|
5176
|
-
|
|
5177
|
-
|
|
5178
|
-
|
|
5179
|
-
|
|
5180
|
-
|
|
5181
|
-
|
|
5182
|
-
|
|
5183
|
-
|
|
5184
|
-
|
|
5185
|
-
|
|
5186
|
-
|
|
5187
|
-
|
|
5188
|
-
|
|
5189
|
-
|
|
5190
|
-
|
|
5191
|
-
|
|
5192
|
-
|
|
5193
|
-
|
|
5194
|
-
|
|
5195
|
-
|
|
5196
|
-
|
|
5197
|
-
|
|
5198
|
-
|
|
5199
|
-
|
|
5200
|
-
|
|
5201
|
-
|
|
5202
|
-
|
|
5203
|
-
|
|
5204
|
-
|
|
5205
|
-
|
|
5206
|
-
|
|
5207
|
-
|
|
5208
|
-
|
|
5209
|
-
|
|
5210
|
-
|
|
5211
|
-
|
|
5212
|
-
|
|
5213
|
-
|
|
5214
|
-
|
|
5215
|
-
}, z.core.$strict>;
|
|
5216
|
-
|
|
5217
|
-
|
|
5218
|
-
|
|
5219
|
-
|
|
5220
|
-
|
|
5221
|
-
|
|
5222
|
-
|
|
5223
|
-
|
|
5224
|
-
|
|
5225
|
-
|
|
5226
|
-
|
|
5227
|
-
|
|
5228
|
-
|
|
5368
|
+
kind: z.ZodEnum<{
|
|
5369
|
+
issue: "issue";
|
|
5370
|
+
"knowledge-gap": "knowledge-gap";
|
|
5371
|
+
}>;
|
|
5372
|
+
change: z.ZodString;
|
|
5373
|
+
gate: z.ZodString;
|
|
5374
|
+
round: z.ZodNumber;
|
|
5375
|
+
rule: z.ZodString;
|
|
5376
|
+
layer: z.ZodEnum<{
|
|
5377
|
+
team: "team";
|
|
5378
|
+
constitution: "constitution";
|
|
5379
|
+
org: "org";
|
|
5380
|
+
}>;
|
|
5381
|
+
lens: z.ZodEnum<{
|
|
5382
|
+
release: "release";
|
|
5383
|
+
true: "true";
|
|
5384
|
+
complete: "complete";
|
|
5385
|
+
safe: "safe";
|
|
5386
|
+
ship: "ship";
|
|
5387
|
+
business: "business";
|
|
5388
|
+
architecture: "architecture";
|
|
5389
|
+
story: "story";
|
|
5390
|
+
ux: "ux";
|
|
5391
|
+
delivery: "delivery";
|
|
5392
|
+
"code-and-test": "code-and-test";
|
|
5393
|
+
}>;
|
|
5394
|
+
severity: z.ZodEnum<{
|
|
5395
|
+
blocking: "blocking";
|
|
5396
|
+
gap: "gap";
|
|
5397
|
+
risk: "risk";
|
|
5398
|
+
idea: "idea";
|
|
5399
|
+
}>;
|
|
5400
|
+
artifact: z.ZodString;
|
|
5401
|
+
locator: z.ZodObject<{
|
|
5402
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5403
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
5404
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5405
|
+
field: z.ZodOptional<z.ZodString>;
|
|
5406
|
+
}, z.core.$strict>;
|
|
5407
|
+
summary: z.ZodString;
|
|
5408
|
+
why: z.ZodString;
|
|
5409
|
+
fix: z.ZodObject<{
|
|
5410
|
+
text: z.ZodString;
|
|
5411
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
5412
|
+
}, z.core.$strict>;
|
|
5413
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
5414
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
5415
|
+
code: "code";
|
|
5416
|
+
config: "config";
|
|
5417
|
+
spec: "spec";
|
|
5418
|
+
gateway: "gateway";
|
|
5419
|
+
"event-config": "event-config";
|
|
5420
|
+
infrastructure: "infrastructure";
|
|
5421
|
+
pipeline: "pipeline";
|
|
5422
|
+
migration: "migration";
|
|
5423
|
+
diagram: "diagram";
|
|
5424
|
+
document: "document";
|
|
5425
|
+
export: "export";
|
|
5426
|
+
manual: "manual";
|
|
5427
|
+
}>, z.ZodEnum<{
|
|
5428
|
+
catalog: "catalog";
|
|
5429
|
+
artifact: "artifact";
|
|
5430
|
+
rule: "rule";
|
|
5431
|
+
}>]>;
|
|
5432
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5433
|
+
path: z.ZodOptional<z.ZodString>;
|
|
5434
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
5435
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5436
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
5437
|
+
}, z.core.$strict>>;
|
|
5438
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
5439
|
+
text: z.ZodString;
|
|
5440
|
+
owner: z.ZodString;
|
|
5441
|
+
}, z.core.$strict>>;
|
|
5442
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
5443
|
+
question: z.ZodString;
|
|
5444
|
+
quote: z.ZodString;
|
|
5445
|
+
}, z.core.$strict>>;
|
|
5446
|
+
waivable: z.ZodBoolean;
|
|
5447
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
5448
|
+
open: "open";
|
|
5449
|
+
applied: "applied";
|
|
5450
|
+
dismissed: "dismissed";
|
|
5451
|
+
waived: "waived";
|
|
5452
|
+
asked: "asked";
|
|
5453
|
+
}>>;
|
|
5454
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
5455
|
+
action: z.ZodEnum<{
|
|
5456
|
+
apply: "apply";
|
|
5457
|
+
"edit-and-apply": "edit-and-apply";
|
|
5458
|
+
"not-relevant": "not-relevant";
|
|
5459
|
+
waive: "waive";
|
|
5460
|
+
ask: "ask";
|
|
5461
|
+
}>;
|
|
5462
|
+
by: z.ZodString;
|
|
5463
|
+
at: z.ZodISODateTime;
|
|
5464
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5465
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5466
|
+
}, z.core.$strict>>;
|
|
5467
|
+
createdAt: z.ZodISODateTime;
|
|
5468
|
+
}, z.core.$strict>;
|
|
5469
|
+
file: z.ZodString;
|
|
5470
|
+
options: z.ZodObject<{
|
|
5471
|
+
fix: z.ZodString;
|
|
5472
|
+
apply: z.ZodBoolean;
|
|
5473
|
+
dismiss: z.ZodBoolean;
|
|
5474
|
+
waive: z.ZodBoolean;
|
|
5475
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
5476
|
+
text: z.ZodString;
|
|
5477
|
+
owner: z.ZodString;
|
|
5478
|
+
}, z.core.$strip>>;
|
|
5479
|
+
}, z.core.$strip>;
|
|
5480
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
5481
|
+
question: z.ZodString;
|
|
5482
|
+
text: z.ZodString;
|
|
5483
|
+
by: z.ZodString;
|
|
5484
|
+
at: z.ZodString;
|
|
5485
|
+
read: z.ZodBoolean;
|
|
5486
|
+
}, z.core.$strip>>;
|
|
5487
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5488
|
+
claim: z.ZodEnum<{
|
|
5489
|
+
fixed: "fixed";
|
|
5490
|
+
"not-relevant": "not-relevant";
|
|
5491
|
+
}>;
|
|
5492
|
+
by: z.ZodString;
|
|
5493
|
+
at: z.ZodString;
|
|
5494
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5495
|
+
}, z.core.$strip>>;
|
|
5496
|
+
}, z.core.$strip>;
|
|
5497
|
+
assistantWrites: z.ZodBoolean;
|
|
5498
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
5499
|
+
artifact: z.ZodString;
|
|
5500
|
+
file: z.ZodOptional<z.ZodString>;
|
|
5501
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5502
|
+
}, z.core.$strip>>;
|
|
5503
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5504
|
+
kind: z.ZodLiteral<"question">;
|
|
5505
|
+
at: z.ZodString;
|
|
5506
|
+
question: z.ZodObject<{
|
|
5507
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
5508
|
+
id: z.ZodString;
|
|
5509
|
+
askedBy: z.ZodObject<{
|
|
5510
|
+
step: z.ZodString;
|
|
5511
|
+
command: z.ZodString;
|
|
5512
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5513
|
+
at: z.ZodISODateTime;
|
|
5514
|
+
}, z.core.$strict>;
|
|
5515
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
5516
|
+
step: z.ZodString;
|
|
5517
|
+
command: z.ZodString;
|
|
5518
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5519
|
+
at: z.ZodISODateTime;
|
|
5520
|
+
rerun: z.ZodString;
|
|
5521
|
+
}, z.core.$strict>>>;
|
|
5522
|
+
repo: z.ZodString;
|
|
5523
|
+
question: z.ZodString;
|
|
5524
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
5525
|
+
label: z.ZodString;
|
|
5526
|
+
means: z.ZodString;
|
|
5527
|
+
changes: z.ZodString;
|
|
5528
|
+
}, z.core.$strict>>>;
|
|
5529
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
5530
|
+
scope: z.ZodObject<{
|
|
5531
|
+
level: z.ZodEnum<{
|
|
5532
|
+
repo: "repo";
|
|
5533
|
+
"repo-type": "repo-type";
|
|
5534
|
+
}>;
|
|
5535
|
+
id: z.ZodString;
|
|
5536
|
+
}, z.core.$strict>;
|
|
5537
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
5538
|
+
product: "product";
|
|
5539
|
+
architecture: "architecture";
|
|
5540
|
+
delivery: "delivery";
|
|
5541
|
+
analysis: "analysis";
|
|
5542
|
+
}>>;
|
|
5543
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
5544
|
+
business: "business";
|
|
5545
|
+
delivery: "delivery";
|
|
5546
|
+
design: "design";
|
|
5547
|
+
}>>;
|
|
5548
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
5549
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
5550
|
+
product: "product";
|
|
5551
|
+
architecture: "architecture";
|
|
5552
|
+
delivery: "delivery";
|
|
5553
|
+
analysis: "analysis";
|
|
5554
|
+
}>>;
|
|
5555
|
+
by: z.ZodString;
|
|
5556
|
+
at: z.ZodISODateTime;
|
|
5557
|
+
}, z.core.$strict>>;
|
|
5558
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5559
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
5560
|
+
change: z.ZodString;
|
|
5561
|
+
gate: z.ZodString;
|
|
5562
|
+
round: z.ZodNumber;
|
|
5563
|
+
id: z.ZodString;
|
|
5564
|
+
}, z.core.$strict>>;
|
|
5565
|
+
state: z.ZodEnum<{
|
|
5566
|
+
retired: "retired";
|
|
5567
|
+
open: "open";
|
|
5568
|
+
answered: "answered";
|
|
5569
|
+
}>;
|
|
5570
|
+
rerun: z.ZodString;
|
|
5571
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
5572
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
5573
|
+
text: z.ZodOptional<z.ZodString>;
|
|
5574
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
5575
|
+
kind: z.ZodLiteral<"ai">;
|
|
5576
|
+
runtime: z.ZodEnum<{
|
|
5577
|
+
"hand-off": "hand-off";
|
|
5578
|
+
"copilot-acp": "copilot-acp";
|
|
5579
|
+
}>;
|
|
5580
|
+
run: z.ZodString;
|
|
5581
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
5582
|
+
confident: "confident";
|
|
5583
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
5584
|
+
"person-rule": "person-rule";
|
|
5585
|
+
}>>;
|
|
5586
|
+
}, z.core.$strict>]>;
|
|
5587
|
+
at: z.ZodISODateTime;
|
|
5588
|
+
scope: z.ZodObject<{
|
|
5589
|
+
level: z.ZodEnum<{
|
|
5590
|
+
repo: "repo";
|
|
5591
|
+
"repo-type": "repo-type";
|
|
5592
|
+
}>;
|
|
5593
|
+
id: z.ZodString;
|
|
5594
|
+
}, z.core.$strict>;
|
|
5595
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
5596
|
+
match: z.ZodOptional<z.ZodString>;
|
|
5597
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5598
|
+
by: z.ZodString;
|
|
5599
|
+
at: z.ZodISODateTime;
|
|
5600
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
5601
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
5602
|
+
file: z.ZodString;
|
|
5603
|
+
line: z.ZodNumber;
|
|
5604
|
+
quote: z.ZodString;
|
|
5605
|
+
}, z.core.$strict>>;
|
|
5606
|
+
}, z.core.$strict>>;
|
|
5607
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
5608
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
5609
|
+
from: z.ZodString;
|
|
5610
|
+
match: z.ZodString;
|
|
5611
|
+
}, z.core.$strict>>;
|
|
5612
|
+
}, z.core.$strict>>;
|
|
5613
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
5614
|
+
at: z.ZodISODateTime;
|
|
5615
|
+
why: z.ZodString;
|
|
5616
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5617
|
+
}, z.core.$strict>>;
|
|
5618
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
5619
|
+
at: z.ZodISODateTime;
|
|
5620
|
+
why: z.ZodString;
|
|
5621
|
+
answer: z.ZodObject<{
|
|
5622
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
5623
|
+
text: z.ZodOptional<z.ZodString>;
|
|
5624
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
5625
|
+
kind: z.ZodLiteral<"ai">;
|
|
5626
|
+
runtime: z.ZodEnum<{
|
|
5627
|
+
"hand-off": "hand-off";
|
|
5628
|
+
"copilot-acp": "copilot-acp";
|
|
5629
|
+
}>;
|
|
5630
|
+
run: z.ZodString;
|
|
5631
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
5632
|
+
confident: "confident";
|
|
5633
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
5634
|
+
"person-rule": "person-rule";
|
|
5635
|
+
}>>;
|
|
5636
|
+
}, z.core.$strict>]>;
|
|
5637
|
+
at: z.ZodISODateTime;
|
|
5638
|
+
scope: z.ZodObject<{
|
|
5639
|
+
level: z.ZodEnum<{
|
|
5640
|
+
repo: "repo";
|
|
5641
|
+
"repo-type": "repo-type";
|
|
5642
|
+
}>;
|
|
5643
|
+
id: z.ZodString;
|
|
5644
|
+
}, z.core.$strict>;
|
|
5645
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
5646
|
+
match: z.ZodOptional<z.ZodString>;
|
|
5647
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5648
|
+
by: z.ZodString;
|
|
5649
|
+
at: z.ZodISODateTime;
|
|
5650
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
5651
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
5652
|
+
file: z.ZodString;
|
|
5653
|
+
line: z.ZodNumber;
|
|
5654
|
+
quote: z.ZodString;
|
|
5655
|
+
}, z.core.$strict>>;
|
|
5656
|
+
}, z.core.$strict>>;
|
|
5657
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
5658
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
5659
|
+
from: z.ZodString;
|
|
5660
|
+
match: z.ZodString;
|
|
5661
|
+
}, z.core.$strict>>;
|
|
5662
|
+
}, z.core.$strict>;
|
|
5663
|
+
}, z.core.$strict>>;
|
|
5664
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
5665
|
+
id: z.ZodString;
|
|
5666
|
+
verdict: z.ZodEnum<{
|
|
5667
|
+
unsure: "unsure";
|
|
5668
|
+
narrower: "narrower";
|
|
5669
|
+
}>;
|
|
5670
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
5671
|
+
}, z.core.$strict>>>;
|
|
5672
|
+
}, z.core.$strict>;
|
|
5673
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5674
|
+
kind: z.ZodLiteral<"reply">;
|
|
5675
|
+
at: z.ZodString;
|
|
5676
|
+
text: z.ZodString;
|
|
5677
|
+
by: z.ZodString;
|
|
5678
|
+
read: z.ZodBoolean;
|
|
5679
|
+
about: z.ZodOptional<z.ZodString>;
|
|
5680
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5681
|
+
kind: z.ZodLiteral<"correction">;
|
|
5682
|
+
at: z.ZodString;
|
|
5683
|
+
text: z.ZodString;
|
|
5684
|
+
label: z.ZodString;
|
|
5685
|
+
by: z.ZodString;
|
|
5686
|
+
state: z.ZodString;
|
|
5687
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5688
|
+
kind: z.ZodLiteral<"dropped">;
|
|
5689
|
+
at: z.ZodString;
|
|
5690
|
+
key: z.ZodString;
|
|
5691
|
+
question: z.ZodString;
|
|
5692
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
5693
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
5694
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5695
|
+
kind: z.ZodLiteral<"note">;
|
|
5696
|
+
at: z.ZodString;
|
|
5697
|
+
text: z.ZodString;
|
|
5698
|
+
}, z.core.$strip>], "kind">;
|
|
5699
|
+
export declare const StageThreadView: z.ZodObject<{
|
|
5700
|
+
change: z.ZodString;
|
|
5701
|
+
stage: z.ZodEnum<{
|
|
5702
|
+
small: "small";
|
|
5703
|
+
architecture: "architecture";
|
|
5704
|
+
proposal: "proposal";
|
|
5705
|
+
stories: "stories";
|
|
5706
|
+
feature: "feature";
|
|
5707
|
+
}>;
|
|
5708
|
+
state: z.ZodEnum<{
|
|
5709
|
+
"not-started": "not-started";
|
|
5710
|
+
done: "done";
|
|
5711
|
+
questions: "questions";
|
|
5712
|
+
waiting: "waiting";
|
|
5713
|
+
stopped: "stopped";
|
|
5714
|
+
drafting: "drafting";
|
|
5715
|
+
}>;
|
|
5716
|
+
headline: z.ZodString;
|
|
5717
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
5718
|
+
kind: z.ZodLiteral<"prompt">;
|
|
5719
|
+
at: z.ZodString;
|
|
5720
|
+
runId: z.ZodString;
|
|
5721
|
+
who: z.ZodEnum<{
|
|
5722
|
+
critic: "critic";
|
|
5723
|
+
drafter: "drafter";
|
|
5724
|
+
}>;
|
|
5725
|
+
prompt: z.ZodString;
|
|
5726
|
+
state: z.ZodEnum<{
|
|
5727
|
+
failed: "failed";
|
|
5728
|
+
prepared: "prepared";
|
|
5729
|
+
waiting: "waiting";
|
|
5730
|
+
produced: "produced";
|
|
5731
|
+
validated: "validated";
|
|
5732
|
+
cancelled: "cancelled";
|
|
5733
|
+
}>;
|
|
5734
|
+
details: z.ZodObject<{
|
|
5735
|
+
agent: z.ZodString;
|
|
5736
|
+
runtime: z.ZodString;
|
|
5737
|
+
promptPath: z.ZodString;
|
|
5738
|
+
output: z.ZodOptional<z.ZodString>;
|
|
5739
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
5740
|
+
model: z.ZodOptional<z.ZodString>;
|
|
5741
|
+
attempt: z.ZodNumber;
|
|
5742
|
+
}, z.core.$strip>;
|
|
5743
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5744
|
+
kind: z.ZodLiteral<"answer">;
|
|
5745
|
+
at: z.ZodString;
|
|
5746
|
+
runId: z.ZodString;
|
|
5747
|
+
who: z.ZodEnum<{
|
|
5748
|
+
critic: "critic";
|
|
5749
|
+
drafter: "drafter";
|
|
5750
|
+
}>;
|
|
5751
|
+
checked: z.ZodEnum<{
|
|
5752
|
+
failed: "failed";
|
|
5753
|
+
passed: "passed";
|
|
5754
|
+
checking: "checking";
|
|
5755
|
+
}>;
|
|
5756
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
5757
|
+
person: "person";
|
|
5758
|
+
app: "app";
|
|
5759
|
+
}>>;
|
|
5760
|
+
summary: z.ZodArray<z.ZodString>;
|
|
5761
|
+
problems: z.ZodArray<z.ZodString>;
|
|
5762
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5763
|
+
kind: z.ZodLiteral<"changed">;
|
|
5764
|
+
at: z.ZodString;
|
|
5765
|
+
files: z.ZodArray<z.ZodString>;
|
|
5766
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5767
|
+
kind: z.ZodLiteral<"finding">;
|
|
5768
|
+
at: z.ZodString;
|
|
5769
|
+
view: z.ZodObject<{
|
|
5770
|
+
finding: z.ZodObject<{
|
|
5771
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
5772
|
+
id: z.ZodString;
|
|
5773
|
+
kind: z.ZodEnum<{
|
|
5774
|
+
issue: "issue";
|
|
5775
|
+
"knowledge-gap": "knowledge-gap";
|
|
5776
|
+
}>;
|
|
5777
|
+
change: z.ZodString;
|
|
5778
|
+
gate: z.ZodString;
|
|
5779
|
+
round: z.ZodNumber;
|
|
5780
|
+
rule: z.ZodString;
|
|
5781
|
+
layer: z.ZodEnum<{
|
|
5782
|
+
team: "team";
|
|
5783
|
+
constitution: "constitution";
|
|
5784
|
+
org: "org";
|
|
5785
|
+
}>;
|
|
5786
|
+
lens: z.ZodEnum<{
|
|
5787
|
+
release: "release";
|
|
5788
|
+
true: "true";
|
|
5789
|
+
complete: "complete";
|
|
5790
|
+
safe: "safe";
|
|
5791
|
+
ship: "ship";
|
|
5792
|
+
business: "business";
|
|
5793
|
+
architecture: "architecture";
|
|
5794
|
+
story: "story";
|
|
5795
|
+
ux: "ux";
|
|
5796
|
+
delivery: "delivery";
|
|
5797
|
+
"code-and-test": "code-and-test";
|
|
5798
|
+
}>;
|
|
5799
|
+
severity: z.ZodEnum<{
|
|
5800
|
+
blocking: "blocking";
|
|
5801
|
+
gap: "gap";
|
|
5802
|
+
risk: "risk";
|
|
5803
|
+
idea: "idea";
|
|
5804
|
+
}>;
|
|
5805
|
+
artifact: z.ZodString;
|
|
5806
|
+
locator: z.ZodObject<{
|
|
5807
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5808
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
5809
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5810
|
+
field: z.ZodOptional<z.ZodString>;
|
|
5811
|
+
}, z.core.$strict>;
|
|
5812
|
+
summary: z.ZodString;
|
|
5813
|
+
why: z.ZodString;
|
|
5814
|
+
fix: z.ZodObject<{
|
|
5815
|
+
text: z.ZodString;
|
|
5816
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
5817
|
+
}, z.core.$strict>;
|
|
5818
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
5819
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
5820
|
+
code: "code";
|
|
5821
|
+
config: "config";
|
|
5822
|
+
spec: "spec";
|
|
5823
|
+
gateway: "gateway";
|
|
5824
|
+
"event-config": "event-config";
|
|
5825
|
+
infrastructure: "infrastructure";
|
|
5826
|
+
pipeline: "pipeline";
|
|
5827
|
+
migration: "migration";
|
|
5828
|
+
diagram: "diagram";
|
|
5829
|
+
document: "document";
|
|
5830
|
+
export: "export";
|
|
5831
|
+
manual: "manual";
|
|
5832
|
+
}>, z.ZodEnum<{
|
|
5833
|
+
catalog: "catalog";
|
|
5834
|
+
artifact: "artifact";
|
|
5835
|
+
rule: "rule";
|
|
5836
|
+
}>]>;
|
|
5837
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5838
|
+
path: z.ZodOptional<z.ZodString>;
|
|
5839
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
5840
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5841
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
5842
|
+
}, z.core.$strict>>;
|
|
5843
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
5844
|
+
text: z.ZodString;
|
|
5845
|
+
owner: z.ZodString;
|
|
5846
|
+
}, z.core.$strict>>;
|
|
5847
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
5848
|
+
question: z.ZodString;
|
|
5849
|
+
quote: z.ZodString;
|
|
5850
|
+
}, z.core.$strict>>;
|
|
5851
|
+
waivable: z.ZodBoolean;
|
|
5852
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
5853
|
+
open: "open";
|
|
5854
|
+
applied: "applied";
|
|
5855
|
+
dismissed: "dismissed";
|
|
5856
|
+
waived: "waived";
|
|
5857
|
+
asked: "asked";
|
|
5858
|
+
}>>;
|
|
5859
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
5860
|
+
action: z.ZodEnum<{
|
|
5861
|
+
apply: "apply";
|
|
5862
|
+
"edit-and-apply": "edit-and-apply";
|
|
5863
|
+
"not-relevant": "not-relevant";
|
|
5864
|
+
waive: "waive";
|
|
5865
|
+
ask: "ask";
|
|
5866
|
+
}>;
|
|
5867
|
+
by: z.ZodString;
|
|
5868
|
+
at: z.ZodISODateTime;
|
|
5869
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5870
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5871
|
+
}, z.core.$strict>>;
|
|
5872
|
+
createdAt: z.ZodISODateTime;
|
|
5873
|
+
}, z.core.$strict>;
|
|
5874
|
+
file: z.ZodString;
|
|
5875
|
+
options: z.ZodObject<{
|
|
5876
|
+
fix: z.ZodString;
|
|
5877
|
+
apply: z.ZodBoolean;
|
|
5878
|
+
dismiss: z.ZodBoolean;
|
|
5879
|
+
waive: z.ZodBoolean;
|
|
5880
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
5881
|
+
text: z.ZodString;
|
|
5882
|
+
owner: z.ZodString;
|
|
5883
|
+
}, z.core.$strip>>;
|
|
5884
|
+
}, z.core.$strip>;
|
|
5885
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
5886
|
+
question: z.ZodString;
|
|
5887
|
+
text: z.ZodString;
|
|
5888
|
+
by: z.ZodString;
|
|
5889
|
+
at: z.ZodString;
|
|
5890
|
+
read: z.ZodBoolean;
|
|
5891
|
+
}, z.core.$strip>>;
|
|
5892
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5893
|
+
claim: z.ZodEnum<{
|
|
5894
|
+
fixed: "fixed";
|
|
5895
|
+
"not-relevant": "not-relevant";
|
|
5896
|
+
}>;
|
|
5897
|
+
by: z.ZodString;
|
|
5898
|
+
at: z.ZodString;
|
|
5899
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5900
|
+
}, z.core.$strip>>;
|
|
5901
|
+
}, z.core.$strip>;
|
|
5902
|
+
assistantWrites: z.ZodBoolean;
|
|
5903
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
5904
|
+
artifact: z.ZodString;
|
|
5905
|
+
file: z.ZodOptional<z.ZodString>;
|
|
5906
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5907
|
+
}, z.core.$strip>>;
|
|
5908
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5909
|
+
kind: z.ZodLiteral<"question">;
|
|
5910
|
+
at: z.ZodString;
|
|
5911
|
+
question: z.ZodObject<{
|
|
5912
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
5913
|
+
id: z.ZodString;
|
|
5914
|
+
askedBy: z.ZodObject<{
|
|
5915
|
+
step: z.ZodString;
|
|
5916
|
+
command: z.ZodString;
|
|
5917
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5918
|
+
at: z.ZodISODateTime;
|
|
5919
|
+
}, z.core.$strict>;
|
|
5920
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
5921
|
+
step: z.ZodString;
|
|
5922
|
+
command: z.ZodString;
|
|
5923
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5924
|
+
at: z.ZodISODateTime;
|
|
5925
|
+
rerun: z.ZodString;
|
|
5926
|
+
}, z.core.$strict>>>;
|
|
5927
|
+
repo: z.ZodString;
|
|
5928
|
+
question: z.ZodString;
|
|
5929
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
5930
|
+
label: z.ZodString;
|
|
5931
|
+
means: z.ZodString;
|
|
5932
|
+
changes: z.ZodString;
|
|
5933
|
+
}, z.core.$strict>>>;
|
|
5934
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
5935
|
+
scope: z.ZodObject<{
|
|
5936
|
+
level: z.ZodEnum<{
|
|
5937
|
+
repo: "repo";
|
|
5938
|
+
"repo-type": "repo-type";
|
|
5939
|
+
}>;
|
|
5940
|
+
id: z.ZodString;
|
|
5941
|
+
}, z.core.$strict>;
|
|
5942
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
5943
|
+
product: "product";
|
|
5944
|
+
architecture: "architecture";
|
|
5945
|
+
delivery: "delivery";
|
|
5946
|
+
analysis: "analysis";
|
|
5947
|
+
}>>;
|
|
5948
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
5949
|
+
business: "business";
|
|
5950
|
+
delivery: "delivery";
|
|
5951
|
+
design: "design";
|
|
5952
|
+
}>>;
|
|
5953
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
5954
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
5955
|
+
product: "product";
|
|
5956
|
+
architecture: "architecture";
|
|
5957
|
+
delivery: "delivery";
|
|
5958
|
+
analysis: "analysis";
|
|
5959
|
+
}>>;
|
|
5960
|
+
by: z.ZodString;
|
|
5961
|
+
at: z.ZodISODateTime;
|
|
5962
|
+
}, z.core.$strict>>;
|
|
5963
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5964
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
5965
|
+
change: z.ZodString;
|
|
5966
|
+
gate: z.ZodString;
|
|
5967
|
+
round: z.ZodNumber;
|
|
5968
|
+
id: z.ZodString;
|
|
5969
|
+
}, z.core.$strict>>;
|
|
5970
|
+
state: z.ZodEnum<{
|
|
5971
|
+
retired: "retired";
|
|
5972
|
+
open: "open";
|
|
5973
|
+
answered: "answered";
|
|
5974
|
+
}>;
|
|
5975
|
+
rerun: z.ZodString;
|
|
5976
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
5977
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
5978
|
+
text: z.ZodOptional<z.ZodString>;
|
|
5979
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
5980
|
+
kind: z.ZodLiteral<"ai">;
|
|
5981
|
+
runtime: z.ZodEnum<{
|
|
5982
|
+
"hand-off": "hand-off";
|
|
5983
|
+
"copilot-acp": "copilot-acp";
|
|
5984
|
+
}>;
|
|
5985
|
+
run: z.ZodString;
|
|
5986
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
5987
|
+
confident: "confident";
|
|
5988
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
5989
|
+
"person-rule": "person-rule";
|
|
5990
|
+
}>>;
|
|
5991
|
+
}, z.core.$strict>]>;
|
|
5992
|
+
at: z.ZodISODateTime;
|
|
5993
|
+
scope: z.ZodObject<{
|
|
5994
|
+
level: z.ZodEnum<{
|
|
5995
|
+
repo: "repo";
|
|
5996
|
+
"repo-type": "repo-type";
|
|
5997
|
+
}>;
|
|
5998
|
+
id: z.ZodString;
|
|
5999
|
+
}, z.core.$strict>;
|
|
6000
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6001
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6002
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6003
|
+
by: z.ZodString;
|
|
6004
|
+
at: z.ZodISODateTime;
|
|
6005
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6006
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6007
|
+
file: z.ZodString;
|
|
6008
|
+
line: z.ZodNumber;
|
|
6009
|
+
quote: z.ZodString;
|
|
6010
|
+
}, z.core.$strict>>;
|
|
6011
|
+
}, z.core.$strict>>;
|
|
6012
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6013
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6014
|
+
from: z.ZodString;
|
|
6015
|
+
match: z.ZodString;
|
|
6016
|
+
}, z.core.$strict>>;
|
|
6017
|
+
}, z.core.$strict>>;
|
|
6018
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
6019
|
+
at: z.ZodISODateTime;
|
|
6020
|
+
why: z.ZodString;
|
|
6021
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6022
|
+
}, z.core.$strict>>;
|
|
6023
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
6024
|
+
at: z.ZodISODateTime;
|
|
6025
|
+
why: z.ZodString;
|
|
6026
|
+
answer: z.ZodObject<{
|
|
6027
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6028
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6029
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6030
|
+
kind: z.ZodLiteral<"ai">;
|
|
6031
|
+
runtime: z.ZodEnum<{
|
|
6032
|
+
"hand-off": "hand-off";
|
|
6033
|
+
"copilot-acp": "copilot-acp";
|
|
6034
|
+
}>;
|
|
6035
|
+
run: z.ZodString;
|
|
6036
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6037
|
+
confident: "confident";
|
|
6038
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6039
|
+
"person-rule": "person-rule";
|
|
6040
|
+
}>>;
|
|
6041
|
+
}, z.core.$strict>]>;
|
|
6042
|
+
at: z.ZodISODateTime;
|
|
6043
|
+
scope: z.ZodObject<{
|
|
6044
|
+
level: z.ZodEnum<{
|
|
6045
|
+
repo: "repo";
|
|
6046
|
+
"repo-type": "repo-type";
|
|
6047
|
+
}>;
|
|
6048
|
+
id: z.ZodString;
|
|
6049
|
+
}, z.core.$strict>;
|
|
6050
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6051
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6052
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6053
|
+
by: z.ZodString;
|
|
6054
|
+
at: z.ZodISODateTime;
|
|
6055
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6056
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6057
|
+
file: z.ZodString;
|
|
6058
|
+
line: z.ZodNumber;
|
|
6059
|
+
quote: z.ZodString;
|
|
6060
|
+
}, z.core.$strict>>;
|
|
6061
|
+
}, z.core.$strict>>;
|
|
6062
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6063
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6064
|
+
from: z.ZodString;
|
|
6065
|
+
match: z.ZodString;
|
|
6066
|
+
}, z.core.$strict>>;
|
|
6067
|
+
}, z.core.$strict>;
|
|
6068
|
+
}, z.core.$strict>>;
|
|
6069
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6070
|
+
id: z.ZodString;
|
|
6071
|
+
verdict: z.ZodEnum<{
|
|
6072
|
+
unsure: "unsure";
|
|
6073
|
+
narrower: "narrower";
|
|
6074
|
+
}>;
|
|
6075
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
6076
|
+
}, z.core.$strict>>>;
|
|
6077
|
+
}, z.core.$strict>;
|
|
6078
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6079
|
+
kind: z.ZodLiteral<"reply">;
|
|
6080
|
+
at: z.ZodString;
|
|
6081
|
+
text: z.ZodString;
|
|
6082
|
+
by: z.ZodString;
|
|
6083
|
+
read: z.ZodBoolean;
|
|
6084
|
+
about: z.ZodOptional<z.ZodString>;
|
|
6085
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6086
|
+
kind: z.ZodLiteral<"correction">;
|
|
6087
|
+
at: z.ZodString;
|
|
6088
|
+
text: z.ZodString;
|
|
6089
|
+
label: z.ZodString;
|
|
6090
|
+
by: z.ZodString;
|
|
6091
|
+
state: z.ZodString;
|
|
6092
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6093
|
+
kind: z.ZodLiteral<"dropped">;
|
|
6094
|
+
at: z.ZodString;
|
|
6095
|
+
key: z.ZodString;
|
|
6096
|
+
question: z.ZodString;
|
|
6097
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6098
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
6099
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6100
|
+
kind: z.ZodLiteral<"note">;
|
|
6101
|
+
at: z.ZodString;
|
|
6102
|
+
text: z.ZodString;
|
|
6103
|
+
}, z.core.$strip>], "kind">>;
|
|
6104
|
+
waiting: z.ZodOptional<z.ZodObject<{
|
|
6105
|
+
runId: z.ZodString;
|
|
6106
|
+
prompt: z.ZodString;
|
|
6107
|
+
}, z.core.$strip>>;
|
|
6108
|
+
step: z.ZodArray<z.ZodString>;
|
|
6109
|
+
reply: z.ZodObject<{
|
|
6110
|
+
open: z.ZodBoolean;
|
|
6111
|
+
why: z.ZodOptional<z.ZodString>;
|
|
6112
|
+
}, z.core.$strip>;
|
|
6113
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6114
|
+
file: z.ZodString;
|
|
6115
|
+
message: z.ZodString;
|
|
6116
|
+
}, z.core.$strip>>;
|
|
6117
|
+
}, z.core.$strip>;
|
|
6118
|
+
export declare const StageThreadPost: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
6119
|
+
kind: z.ZodLiteral<"reply">;
|
|
6120
|
+
text: z.ZodString;
|
|
6121
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
6122
|
+
kind: z.ZodLiteral<"finding">;
|
|
6123
|
+
finding: z.ZodString;
|
|
6124
|
+
gate: z.ZodOptional<z.ZodString>;
|
|
6125
|
+
text: z.ZodString;
|
|
6126
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
6127
|
+
kind: z.ZodLiteral<"keep">;
|
|
6128
|
+
key: z.ZodString;
|
|
6129
|
+
}, z.core.$strict>], "kind">;
|
|
6130
|
+
export declare const StageThreadPostResult: z.ZodObject<{
|
|
6131
|
+
files: z.ZodArray<z.ZodString>;
|
|
6132
|
+
thread: z.ZodObject<{
|
|
6133
|
+
change: z.ZodString;
|
|
6134
|
+
stage: z.ZodEnum<{
|
|
6135
|
+
small: "small";
|
|
6136
|
+
architecture: "architecture";
|
|
6137
|
+
proposal: "proposal";
|
|
6138
|
+
stories: "stories";
|
|
6139
|
+
feature: "feature";
|
|
6140
|
+
}>;
|
|
6141
|
+
state: z.ZodEnum<{
|
|
6142
|
+
"not-started": "not-started";
|
|
6143
|
+
done: "done";
|
|
6144
|
+
questions: "questions";
|
|
6145
|
+
waiting: "waiting";
|
|
6146
|
+
stopped: "stopped";
|
|
6147
|
+
drafting: "drafting";
|
|
6148
|
+
}>;
|
|
6149
|
+
headline: z.ZodString;
|
|
6150
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
6151
|
+
kind: z.ZodLiteral<"prompt">;
|
|
6152
|
+
at: z.ZodString;
|
|
6153
|
+
runId: z.ZodString;
|
|
6154
|
+
who: z.ZodEnum<{
|
|
6155
|
+
critic: "critic";
|
|
6156
|
+
drafter: "drafter";
|
|
6157
|
+
}>;
|
|
6158
|
+
prompt: z.ZodString;
|
|
6159
|
+
state: z.ZodEnum<{
|
|
6160
|
+
failed: "failed";
|
|
6161
|
+
prepared: "prepared";
|
|
6162
|
+
waiting: "waiting";
|
|
6163
|
+
produced: "produced";
|
|
6164
|
+
validated: "validated";
|
|
6165
|
+
cancelled: "cancelled";
|
|
6166
|
+
}>;
|
|
6167
|
+
details: z.ZodObject<{
|
|
6168
|
+
agent: z.ZodString;
|
|
6169
|
+
runtime: z.ZodString;
|
|
6170
|
+
promptPath: z.ZodString;
|
|
6171
|
+
output: z.ZodOptional<z.ZodString>;
|
|
6172
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
6173
|
+
model: z.ZodOptional<z.ZodString>;
|
|
6174
|
+
attempt: z.ZodNumber;
|
|
6175
|
+
}, z.core.$strip>;
|
|
6176
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6177
|
+
kind: z.ZodLiteral<"answer">;
|
|
6178
|
+
at: z.ZodString;
|
|
6179
|
+
runId: z.ZodString;
|
|
6180
|
+
who: z.ZodEnum<{
|
|
6181
|
+
critic: "critic";
|
|
6182
|
+
drafter: "drafter";
|
|
6183
|
+
}>;
|
|
6184
|
+
checked: z.ZodEnum<{
|
|
6185
|
+
failed: "failed";
|
|
6186
|
+
passed: "passed";
|
|
6187
|
+
checking: "checking";
|
|
6188
|
+
}>;
|
|
6189
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
6190
|
+
person: "person";
|
|
6191
|
+
app: "app";
|
|
6192
|
+
}>>;
|
|
6193
|
+
summary: z.ZodArray<z.ZodString>;
|
|
6194
|
+
problems: z.ZodArray<z.ZodString>;
|
|
6195
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6196
|
+
kind: z.ZodLiteral<"changed">;
|
|
6197
|
+
at: z.ZodString;
|
|
6198
|
+
files: z.ZodArray<z.ZodString>;
|
|
6199
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6200
|
+
kind: z.ZodLiteral<"finding">;
|
|
6201
|
+
at: z.ZodString;
|
|
6202
|
+
view: z.ZodObject<{
|
|
6203
|
+
finding: z.ZodObject<{
|
|
6204
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
6205
|
+
id: z.ZodString;
|
|
6206
|
+
kind: z.ZodEnum<{
|
|
6207
|
+
issue: "issue";
|
|
6208
|
+
"knowledge-gap": "knowledge-gap";
|
|
6209
|
+
}>;
|
|
6210
|
+
change: z.ZodString;
|
|
6211
|
+
gate: z.ZodString;
|
|
6212
|
+
round: z.ZodNumber;
|
|
6213
|
+
rule: z.ZodString;
|
|
6214
|
+
layer: z.ZodEnum<{
|
|
6215
|
+
team: "team";
|
|
6216
|
+
constitution: "constitution";
|
|
6217
|
+
org: "org";
|
|
6218
|
+
}>;
|
|
6219
|
+
lens: z.ZodEnum<{
|
|
6220
|
+
release: "release";
|
|
6221
|
+
true: "true";
|
|
6222
|
+
complete: "complete";
|
|
6223
|
+
safe: "safe";
|
|
6224
|
+
ship: "ship";
|
|
6225
|
+
business: "business";
|
|
6226
|
+
architecture: "architecture";
|
|
6227
|
+
story: "story";
|
|
6228
|
+
ux: "ux";
|
|
6229
|
+
delivery: "delivery";
|
|
6230
|
+
"code-and-test": "code-and-test";
|
|
6231
|
+
}>;
|
|
6232
|
+
severity: z.ZodEnum<{
|
|
6233
|
+
blocking: "blocking";
|
|
6234
|
+
gap: "gap";
|
|
6235
|
+
risk: "risk";
|
|
6236
|
+
idea: "idea";
|
|
6237
|
+
}>;
|
|
6238
|
+
artifact: z.ZodString;
|
|
6239
|
+
locator: z.ZodObject<{
|
|
6240
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6241
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
6242
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6243
|
+
field: z.ZodOptional<z.ZodString>;
|
|
6244
|
+
}, z.core.$strict>;
|
|
6245
|
+
summary: z.ZodString;
|
|
6246
|
+
why: z.ZodString;
|
|
6247
|
+
fix: z.ZodObject<{
|
|
6248
|
+
text: z.ZodString;
|
|
6249
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
6250
|
+
}, z.core.$strict>;
|
|
6251
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
6252
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
6253
|
+
code: "code";
|
|
6254
|
+
config: "config";
|
|
6255
|
+
spec: "spec";
|
|
6256
|
+
gateway: "gateway";
|
|
6257
|
+
"event-config": "event-config";
|
|
6258
|
+
infrastructure: "infrastructure";
|
|
6259
|
+
pipeline: "pipeline";
|
|
6260
|
+
migration: "migration";
|
|
6261
|
+
diagram: "diagram";
|
|
6262
|
+
document: "document";
|
|
6263
|
+
export: "export";
|
|
6264
|
+
manual: "manual";
|
|
6265
|
+
}>, z.ZodEnum<{
|
|
6266
|
+
catalog: "catalog";
|
|
6267
|
+
artifact: "artifact";
|
|
6268
|
+
rule: "rule";
|
|
6269
|
+
}>]>;
|
|
6270
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6271
|
+
path: z.ZodOptional<z.ZodString>;
|
|
6272
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6273
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6274
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
6275
|
+
}, z.core.$strict>>;
|
|
6276
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
6277
|
+
text: z.ZodString;
|
|
6278
|
+
owner: z.ZodString;
|
|
6279
|
+
}, z.core.$strict>>;
|
|
6280
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
6281
|
+
question: z.ZodString;
|
|
6282
|
+
quote: z.ZodString;
|
|
6283
|
+
}, z.core.$strict>>;
|
|
6284
|
+
waivable: z.ZodBoolean;
|
|
6285
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
6286
|
+
open: "open";
|
|
6287
|
+
applied: "applied";
|
|
6288
|
+
dismissed: "dismissed";
|
|
6289
|
+
waived: "waived";
|
|
6290
|
+
asked: "asked";
|
|
6291
|
+
}>>;
|
|
6292
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
6293
|
+
action: z.ZodEnum<{
|
|
6294
|
+
apply: "apply";
|
|
6295
|
+
"edit-and-apply": "edit-and-apply";
|
|
6296
|
+
"not-relevant": "not-relevant";
|
|
6297
|
+
waive: "waive";
|
|
6298
|
+
ask: "ask";
|
|
6299
|
+
}>;
|
|
6300
|
+
by: z.ZodString;
|
|
6301
|
+
at: z.ZodISODateTime;
|
|
6302
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6303
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6304
|
+
}, z.core.$strict>>;
|
|
6305
|
+
createdAt: z.ZodISODateTime;
|
|
6306
|
+
}, z.core.$strict>;
|
|
6307
|
+
file: z.ZodString;
|
|
6308
|
+
options: z.ZodObject<{
|
|
6309
|
+
fix: z.ZodString;
|
|
6310
|
+
apply: z.ZodBoolean;
|
|
6311
|
+
dismiss: z.ZodBoolean;
|
|
6312
|
+
waive: z.ZodBoolean;
|
|
6313
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
6314
|
+
text: z.ZodString;
|
|
6315
|
+
owner: z.ZodString;
|
|
6316
|
+
}, z.core.$strip>>;
|
|
6317
|
+
}, z.core.$strip>;
|
|
6318
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
6319
|
+
question: z.ZodString;
|
|
6320
|
+
text: z.ZodString;
|
|
6321
|
+
by: z.ZodString;
|
|
6322
|
+
at: z.ZodString;
|
|
6323
|
+
read: z.ZodBoolean;
|
|
6324
|
+
}, z.core.$strip>>;
|
|
6325
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6326
|
+
claim: z.ZodEnum<{
|
|
6327
|
+
fixed: "fixed";
|
|
6328
|
+
"not-relevant": "not-relevant";
|
|
6329
|
+
}>;
|
|
6330
|
+
by: z.ZodString;
|
|
6331
|
+
at: z.ZodString;
|
|
6332
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6333
|
+
}, z.core.$strip>>;
|
|
6334
|
+
}, z.core.$strip>;
|
|
6335
|
+
assistantWrites: z.ZodBoolean;
|
|
6336
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
6337
|
+
artifact: z.ZodString;
|
|
6338
|
+
file: z.ZodOptional<z.ZodString>;
|
|
6339
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6340
|
+
}, z.core.$strip>>;
|
|
6341
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6342
|
+
kind: z.ZodLiteral<"question">;
|
|
6343
|
+
at: z.ZodString;
|
|
6344
|
+
question: z.ZodObject<{
|
|
6345
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
6346
|
+
id: z.ZodString;
|
|
6347
|
+
askedBy: z.ZodObject<{
|
|
6348
|
+
step: z.ZodString;
|
|
6349
|
+
command: z.ZodString;
|
|
6350
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6351
|
+
at: z.ZodISODateTime;
|
|
6352
|
+
}, z.core.$strict>;
|
|
6353
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6354
|
+
step: z.ZodString;
|
|
6355
|
+
command: z.ZodString;
|
|
6356
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6357
|
+
at: z.ZodISODateTime;
|
|
6358
|
+
rerun: z.ZodString;
|
|
6359
|
+
}, z.core.$strict>>>;
|
|
6360
|
+
repo: z.ZodString;
|
|
6361
|
+
question: z.ZodString;
|
|
6362
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
6363
|
+
label: z.ZodString;
|
|
6364
|
+
means: z.ZodString;
|
|
6365
|
+
changes: z.ZodString;
|
|
6366
|
+
}, z.core.$strict>>>;
|
|
6367
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6368
|
+
scope: z.ZodObject<{
|
|
6369
|
+
level: z.ZodEnum<{
|
|
6370
|
+
repo: "repo";
|
|
6371
|
+
"repo-type": "repo-type";
|
|
6372
|
+
}>;
|
|
6373
|
+
id: z.ZodString;
|
|
6374
|
+
}, z.core.$strict>;
|
|
6375
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
6376
|
+
product: "product";
|
|
6377
|
+
architecture: "architecture";
|
|
6378
|
+
delivery: "delivery";
|
|
6379
|
+
analysis: "analysis";
|
|
6380
|
+
}>>;
|
|
6381
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
6382
|
+
business: "business";
|
|
6383
|
+
delivery: "delivery";
|
|
6384
|
+
design: "design";
|
|
6385
|
+
}>>;
|
|
6386
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
6387
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
6388
|
+
product: "product";
|
|
6389
|
+
architecture: "architecture";
|
|
6390
|
+
delivery: "delivery";
|
|
6391
|
+
analysis: "analysis";
|
|
6392
|
+
}>>;
|
|
6393
|
+
by: z.ZodString;
|
|
6394
|
+
at: z.ZodISODateTime;
|
|
6395
|
+
}, z.core.$strict>>;
|
|
6396
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6397
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6398
|
+
change: z.ZodString;
|
|
6399
|
+
gate: z.ZodString;
|
|
6400
|
+
round: z.ZodNumber;
|
|
6401
|
+
id: z.ZodString;
|
|
6402
|
+
}, z.core.$strict>>;
|
|
6403
|
+
state: z.ZodEnum<{
|
|
6404
|
+
retired: "retired";
|
|
6405
|
+
open: "open";
|
|
6406
|
+
answered: "answered";
|
|
6407
|
+
}>;
|
|
6408
|
+
rerun: z.ZodString;
|
|
6409
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
6410
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6411
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6412
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6413
|
+
kind: z.ZodLiteral<"ai">;
|
|
6414
|
+
runtime: z.ZodEnum<{
|
|
6415
|
+
"hand-off": "hand-off";
|
|
6416
|
+
"copilot-acp": "copilot-acp";
|
|
6417
|
+
}>;
|
|
6418
|
+
run: z.ZodString;
|
|
6419
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6420
|
+
confident: "confident";
|
|
6421
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6422
|
+
"person-rule": "person-rule";
|
|
6423
|
+
}>>;
|
|
6424
|
+
}, z.core.$strict>]>;
|
|
6425
|
+
at: z.ZodISODateTime;
|
|
6426
|
+
scope: z.ZodObject<{
|
|
6427
|
+
level: z.ZodEnum<{
|
|
6428
|
+
repo: "repo";
|
|
6429
|
+
"repo-type": "repo-type";
|
|
6430
|
+
}>;
|
|
6431
|
+
id: z.ZodString;
|
|
6432
|
+
}, z.core.$strict>;
|
|
6433
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6434
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6435
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6436
|
+
by: z.ZodString;
|
|
6437
|
+
at: z.ZodISODateTime;
|
|
6438
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6439
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6440
|
+
file: z.ZodString;
|
|
6441
|
+
line: z.ZodNumber;
|
|
6442
|
+
quote: z.ZodString;
|
|
6443
|
+
}, z.core.$strict>>;
|
|
6444
|
+
}, z.core.$strict>>;
|
|
6445
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6446
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6447
|
+
from: z.ZodString;
|
|
6448
|
+
match: z.ZodString;
|
|
6449
|
+
}, z.core.$strict>>;
|
|
6450
|
+
}, z.core.$strict>>;
|
|
6451
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
6452
|
+
at: z.ZodISODateTime;
|
|
6453
|
+
why: z.ZodString;
|
|
6454
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6455
|
+
}, z.core.$strict>>;
|
|
6456
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
6457
|
+
at: z.ZodISODateTime;
|
|
6458
|
+
why: z.ZodString;
|
|
6459
|
+
answer: z.ZodObject<{
|
|
6460
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6461
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6462
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6463
|
+
kind: z.ZodLiteral<"ai">;
|
|
6464
|
+
runtime: z.ZodEnum<{
|
|
6465
|
+
"hand-off": "hand-off";
|
|
6466
|
+
"copilot-acp": "copilot-acp";
|
|
6467
|
+
}>;
|
|
6468
|
+
run: z.ZodString;
|
|
6469
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6470
|
+
confident: "confident";
|
|
6471
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6472
|
+
"person-rule": "person-rule";
|
|
6473
|
+
}>>;
|
|
6474
|
+
}, z.core.$strict>]>;
|
|
6475
|
+
at: z.ZodISODateTime;
|
|
6476
|
+
scope: z.ZodObject<{
|
|
6477
|
+
level: z.ZodEnum<{
|
|
6478
|
+
repo: "repo";
|
|
6479
|
+
"repo-type": "repo-type";
|
|
6480
|
+
}>;
|
|
6481
|
+
id: z.ZodString;
|
|
6482
|
+
}, z.core.$strict>;
|
|
6483
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6484
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6485
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6486
|
+
by: z.ZodString;
|
|
6487
|
+
at: z.ZodISODateTime;
|
|
6488
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6489
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6490
|
+
file: z.ZodString;
|
|
6491
|
+
line: z.ZodNumber;
|
|
6492
|
+
quote: z.ZodString;
|
|
6493
|
+
}, z.core.$strict>>;
|
|
6494
|
+
}, z.core.$strict>>;
|
|
6495
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6496
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6497
|
+
from: z.ZodString;
|
|
6498
|
+
match: z.ZodString;
|
|
6499
|
+
}, z.core.$strict>>;
|
|
6500
|
+
}, z.core.$strict>;
|
|
6501
|
+
}, z.core.$strict>>;
|
|
6502
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6503
|
+
id: z.ZodString;
|
|
6504
|
+
verdict: z.ZodEnum<{
|
|
6505
|
+
unsure: "unsure";
|
|
6506
|
+
narrower: "narrower";
|
|
6507
|
+
}>;
|
|
6508
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
6509
|
+
}, z.core.$strict>>>;
|
|
6510
|
+
}, z.core.$strict>;
|
|
6511
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6512
|
+
kind: z.ZodLiteral<"reply">;
|
|
6513
|
+
at: z.ZodString;
|
|
6514
|
+
text: z.ZodString;
|
|
6515
|
+
by: z.ZodString;
|
|
6516
|
+
read: z.ZodBoolean;
|
|
6517
|
+
about: z.ZodOptional<z.ZodString>;
|
|
6518
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6519
|
+
kind: z.ZodLiteral<"correction">;
|
|
6520
|
+
at: z.ZodString;
|
|
6521
|
+
text: z.ZodString;
|
|
6522
|
+
label: z.ZodString;
|
|
6523
|
+
by: z.ZodString;
|
|
6524
|
+
state: z.ZodString;
|
|
6525
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6526
|
+
kind: z.ZodLiteral<"dropped">;
|
|
6527
|
+
at: z.ZodString;
|
|
6528
|
+
key: z.ZodString;
|
|
6529
|
+
question: z.ZodString;
|
|
6530
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6531
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
6532
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6533
|
+
kind: z.ZodLiteral<"note">;
|
|
6534
|
+
at: z.ZodString;
|
|
6535
|
+
text: z.ZodString;
|
|
6536
|
+
}, z.core.$strip>], "kind">>;
|
|
6537
|
+
waiting: z.ZodOptional<z.ZodObject<{
|
|
6538
|
+
runId: z.ZodString;
|
|
6539
|
+
prompt: z.ZodString;
|
|
6540
|
+
}, z.core.$strip>>;
|
|
6541
|
+
step: z.ZodArray<z.ZodString>;
|
|
6542
|
+
reply: z.ZodObject<{
|
|
6543
|
+
open: z.ZodBoolean;
|
|
6544
|
+
why: z.ZodOptional<z.ZodString>;
|
|
6545
|
+
}, z.core.$strip>;
|
|
6546
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6547
|
+
file: z.ZodString;
|
|
6548
|
+
message: z.ZodString;
|
|
6549
|
+
}, z.core.$strip>>;
|
|
6550
|
+
}, z.core.$strip>;
|
|
6551
|
+
}, z.core.$strip>;
|
|
6552
|
+
export type ThreadStageT = z.infer<typeof ThreadStage>;
|
|
6553
|
+
export type ThreadItemT = z.infer<typeof ThreadItem>;
|
|
6554
|
+
export type StageThreadViewT = z.infer<typeof StageThreadView>;
|
|
6555
|
+
export type StageThreadPostT = z.infer<typeof StageThreadPost>;
|
|
6556
|
+
export type StageThreadPostResultT = z.infer<typeof StageThreadPostResult>;
|
|
6557
|
+
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
6558
|
+
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
6559
|
+
/**
|
|
6560
|
+
* 2.80.0 (ADR 0181, stage drafts): AI decides first, a person corrects, and the AI corrects the
|
|
6561
|
+
* rest like it. A page's stage drafts (Feature design: feature.md and proposal.md; Architecture:
|
|
6562
|
+
* the target flows, design.md and data.md; Stories: the stories and the specs; Tasks: tasks.md),
|
|
6563
|
+
* each with who wrote it last (`drafted`: the AI with its stage and run, from
|
|
6564
|
+
* `stage/drafted.yaml`, until a person saves it) and the items a person can correct. A
|
|
6565
|
+
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
6566
|
+
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
6567
|
+
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
6568
|
+
* the draft changed for it. Kept on file either way.
|
|
6569
|
+
*/
|
|
6570
|
+
export declare const DRAFT_PAGES: readonly ["feature", "architecture", "stories", "tasks"];
|
|
6571
|
+
export declare const DraftPage: z.ZodEnum<{
|
|
6572
|
+
architecture: "architecture";
|
|
6573
|
+
stories: "stories";
|
|
6574
|
+
tasks: "tasks";
|
|
6575
|
+
feature: "feature";
|
|
6576
|
+
}>;
|
|
6577
|
+
export declare const DraftProvenance: z.ZodObject<{
|
|
6578
|
+
by: z.ZodEnum<{
|
|
6579
|
+
ai: "ai";
|
|
6580
|
+
person: "person";
|
|
6581
|
+
}>;
|
|
6582
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
6583
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6584
|
+
who: z.ZodOptional<z.ZodString>;
|
|
6585
|
+
at: z.ZodOptional<z.ZodString>;
|
|
6586
|
+
}, z.core.$strip>;
|
|
6587
|
+
export declare const DraftItemView: z.ZodObject<{
|
|
6588
|
+
id: z.ZodString;
|
|
6589
|
+
label: z.ZodString;
|
|
6590
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6591
|
+
}, z.core.$strip>;
|
|
6592
|
+
export declare const DraftFileView: z.ZodObject<{
|
|
6593
|
+
file: z.ZodString;
|
|
6594
|
+
path: z.ZodString;
|
|
6595
|
+
stage: z.ZodString;
|
|
6596
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
6597
|
+
by: z.ZodEnum<{
|
|
6598
|
+
ai: "ai";
|
|
6599
|
+
person: "person";
|
|
6600
|
+
}>;
|
|
6601
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
6602
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6603
|
+
who: z.ZodOptional<z.ZodString>;
|
|
6604
|
+
at: z.ZodOptional<z.ZodString>;
|
|
6605
|
+
}, z.core.$strip>>;
|
|
6606
|
+
items: z.ZodArray<z.ZodObject<{
|
|
6607
|
+
id: z.ZodString;
|
|
6608
|
+
label: z.ZodString;
|
|
6609
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6610
|
+
}, z.core.$strip>>;
|
|
6611
|
+
}, z.core.$strip>;
|
|
6612
|
+
export declare const CorrectionView: z.ZodObject<{
|
|
6613
|
+
id: z.ZodString;
|
|
6614
|
+
stage: z.ZodString;
|
|
6615
|
+
file: z.ZodString;
|
|
6616
|
+
item: z.ZodOptional<z.ZodString>;
|
|
6617
|
+
label: z.ZodString;
|
|
6618
|
+
text: z.ZodString;
|
|
6619
|
+
scope: z.ZodEnum<{
|
|
6620
|
+
one: "one";
|
|
6621
|
+
similar: "similar";
|
|
6622
|
+
}>;
|
|
6623
|
+
like: z.ZodOptional<z.ZodString>;
|
|
6624
|
+
by: z.ZodString;
|
|
6625
|
+
at: z.ZodString;
|
|
6626
|
+
state: z.ZodEnum<{
|
|
6627
|
+
read: "read";
|
|
6628
|
+
applied: "applied";
|
|
6629
|
+
waiting: "waiting";
|
|
6630
|
+
}>;
|
|
6631
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6632
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
6633
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
6634
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6635
|
+
}, z.core.$strip>;
|
|
6636
|
+
export declare const StageDraftsView: z.ZodObject<{
|
|
6637
|
+
change: z.ZodString;
|
|
6638
|
+
page: z.ZodEnum<{
|
|
6639
|
+
architecture: "architecture";
|
|
6640
|
+
stories: "stories";
|
|
6641
|
+
tasks: "tasks";
|
|
6642
|
+
feature: "feature";
|
|
6643
|
+
}>;
|
|
6644
|
+
files: z.ZodArray<z.ZodObject<{
|
|
6645
|
+
file: z.ZodString;
|
|
6646
|
+
path: z.ZodString;
|
|
6647
|
+
stage: z.ZodString;
|
|
6648
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
6649
|
+
by: z.ZodEnum<{
|
|
6650
|
+
ai: "ai";
|
|
6651
|
+
person: "person";
|
|
6652
|
+
}>;
|
|
6653
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
6654
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6655
|
+
who: z.ZodOptional<z.ZodString>;
|
|
6656
|
+
at: z.ZodOptional<z.ZodString>;
|
|
6657
|
+
}, z.core.$strip>>;
|
|
6658
|
+
items: z.ZodArray<z.ZodObject<{
|
|
6659
|
+
id: z.ZodString;
|
|
6660
|
+
label: z.ZodString;
|
|
6661
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6662
|
+
}, z.core.$strip>>;
|
|
6663
|
+
}, z.core.$strip>>;
|
|
6664
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
6665
|
+
id: z.ZodString;
|
|
6666
|
+
stage: z.ZodString;
|
|
6667
|
+
file: z.ZodString;
|
|
6668
|
+
item: z.ZodOptional<z.ZodString>;
|
|
6669
|
+
label: z.ZodString;
|
|
6670
|
+
text: z.ZodString;
|
|
6671
|
+
scope: z.ZodEnum<{
|
|
6672
|
+
one: "one";
|
|
6673
|
+
similar: "similar";
|
|
6674
|
+
}>;
|
|
6675
|
+
like: z.ZodOptional<z.ZodString>;
|
|
6676
|
+
by: z.ZodString;
|
|
6677
|
+
at: z.ZodString;
|
|
6678
|
+
state: z.ZodEnum<{
|
|
6679
|
+
read: "read";
|
|
6680
|
+
applied: "applied";
|
|
6681
|
+
waiting: "waiting";
|
|
6682
|
+
}>;
|
|
6683
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6684
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
6685
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
6686
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6687
|
+
}, z.core.$strip>>;
|
|
6688
|
+
next: z.ZodObject<{
|
|
6689
|
+
stage: z.ZodString;
|
|
6690
|
+
command: z.ZodString;
|
|
6691
|
+
slash: z.ZodString;
|
|
6692
|
+
}, z.core.$strip>;
|
|
6693
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6694
|
+
file: z.ZodString;
|
|
6695
|
+
message: z.ZodString;
|
|
6696
|
+
}, z.core.$strip>>;
|
|
6697
|
+
}, z.core.$strip>;
|
|
6698
|
+
export declare const AddCorrectionRequest: z.ZodObject<{
|
|
6699
|
+
file: z.ZodString;
|
|
6700
|
+
item: z.ZodOptional<z.ZodString>;
|
|
6701
|
+
text: z.ZodString;
|
|
6702
|
+
similar: z.ZodDefault<z.ZodBoolean>;
|
|
6703
|
+
like: z.ZodOptional<z.ZodString>;
|
|
6704
|
+
}, z.core.$strict>;
|
|
6705
|
+
export declare const CorrectionResult: z.ZodObject<{
|
|
6706
|
+
correction: z.ZodObject<{
|
|
6707
|
+
id: z.ZodString;
|
|
6708
|
+
stage: z.ZodString;
|
|
6709
|
+
file: z.ZodString;
|
|
6710
|
+
item: z.ZodOptional<z.ZodString>;
|
|
6711
|
+
label: z.ZodString;
|
|
6712
|
+
text: z.ZodString;
|
|
6713
|
+
scope: z.ZodEnum<{
|
|
6714
|
+
one: "one";
|
|
6715
|
+
similar: "similar";
|
|
6716
|
+
}>;
|
|
6717
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5229
6718
|
by: z.ZodString;
|
|
5230
6719
|
at: z.ZodString;
|
|
5231
6720
|
state: z.ZodEnum<{
|
|
@@ -6361,11 +7850,13 @@ export declare const Health: z.ZodObject<{
|
|
|
6361
7850
|
openspec: z.ZodOptional<z.ZodString>;
|
|
6362
7851
|
user: z.ZodString;
|
|
6363
7852
|
full: z.ZodOptional<z.ZodBoolean>;
|
|
7853
|
+
metarepo: z.ZodOptional<z.ZodBoolean>;
|
|
6364
7854
|
}, z.core.$strip>;
|
|
6365
7855
|
export declare const ScanRequest: z.ZodObject<{
|
|
6366
7856
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6367
7857
|
full: z.ZodDefault<z.ZodBoolean>;
|
|
6368
7858
|
ref: z.ZodOptional<z.ZodString>;
|
|
7859
|
+
askAll: z.ZodOptional<z.ZodBoolean>;
|
|
6369
7860
|
}, z.core.$strict>;
|
|
6370
7861
|
/** ADR 0123: each repo's branches, as the Repos screen shows them. */
|
|
6371
7862
|
export declare const RepoBranchesView: z.ZodObject<{
|
|
@@ -6527,6 +8018,15 @@ export declare const ChangeCockpit: z.ZodObject<{
|
|
|
6527
8018
|
delivery: "delivery";
|
|
6528
8019
|
analysis: "analysis";
|
|
6529
8020
|
}>>>;
|
|
8021
|
+
waitsOn: z.ZodOptional<z.ZodLazy<z.ZodObject<{
|
|
8022
|
+
role: z.ZodString;
|
|
8023
|
+
people: z.ZodArray<z.ZodString>;
|
|
8024
|
+
because: z.ZodEnum<{
|
|
8025
|
+
phase: "phase";
|
|
8026
|
+
handoff: "handoff";
|
|
8027
|
+
}>;
|
|
8028
|
+
phase: z.ZodString;
|
|
8029
|
+
}, z.core.$strip>>>;
|
|
6530
8030
|
repos: z.ZodArray<z.ZodObject<{
|
|
6531
8031
|
id: z.ZodString;
|
|
6532
8032
|
branch: z.ZodString;
|
|
@@ -6552,10 +8052,10 @@ export declare const NewChangeRequest: z.ZodObject<{
|
|
|
6552
8052
|
export declare const ProposeScope: z.ZodEnum<{
|
|
6553
8053
|
"service-desk": "service-desk";
|
|
6554
8054
|
"org-pack": "org-pack";
|
|
8055
|
+
work: "work";
|
|
6555
8056
|
audit: "audit";
|
|
6556
8057
|
corrections: "corrections";
|
|
6557
8058
|
answers: "answers";
|
|
6558
|
-
work: "work";
|
|
6559
8059
|
"owner-answers": "owner-answers";
|
|
6560
8060
|
baseline: "baseline";
|
|
6561
8061
|
initiatives: "initiatives";
|
|
@@ -6565,10 +8065,10 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6565
8065
|
scope: z.ZodEnum<{
|
|
6566
8066
|
"service-desk": "service-desk";
|
|
6567
8067
|
"org-pack": "org-pack";
|
|
8068
|
+
work: "work";
|
|
6568
8069
|
audit: "audit";
|
|
6569
8070
|
corrections: "corrections";
|
|
6570
8071
|
answers: "answers";
|
|
6571
|
-
work: "work";
|
|
6572
8072
|
"owner-answers": "owner-answers";
|
|
6573
8073
|
baseline: "baseline";
|
|
6574
8074
|
initiatives: "initiatives";
|
|
@@ -6592,7 +8092,7 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6592
8092
|
* `merge` is Sync's merge of a ready PR; `ai-model` a change of where runtime.yaml sends the
|
|
6593
8093
|
* model's key (its provider, keyEnv or an address); `ai-test` a Test of settings not committed.
|
|
6594
8094
|
*/
|
|
6595
|
-
export declare const CONFIRMED_WRITES: readonly ["handoff", "release-prs", "merge", "task-pr", "digest-send", "propose", "step-run", "ai-model", "ai-test"];
|
|
8095
|
+
export declare const CONFIRMED_WRITES: readonly ["handoff", "release-prs", "merge", "task-pr", "digest-send", "propose", "step-run", "ai-model", "ai-test", "work-items", "owner-ask"];
|
|
6596
8096
|
export declare const ConfirmedWrite: z.ZodEnum<{
|
|
6597
8097
|
propose: "propose";
|
|
6598
8098
|
handoff: "handoff";
|
|
@@ -6603,6 +8103,8 @@ export declare const ConfirmedWrite: z.ZodEnum<{
|
|
|
6603
8103
|
"step-run": "step-run";
|
|
6604
8104
|
"ai-model": "ai-model";
|
|
6605
8105
|
"ai-test": "ai-test";
|
|
8106
|
+
"work-items": "work-items";
|
|
8107
|
+
"owner-ask": "owner-ask";
|
|
6606
8108
|
}>;
|
|
6607
8109
|
/** A confirmation the server gave the page: single use, for one write and target, two minutes. */
|
|
6608
8110
|
export declare const Confirmation: z.ZodString;
|
|
@@ -6617,6 +8119,8 @@ export declare const ConfirmationRequest: z.ZodObject<{
|
|
|
6617
8119
|
"step-run": "step-run";
|
|
6618
8120
|
"ai-model": "ai-model";
|
|
6619
8121
|
"ai-test": "ai-test";
|
|
8122
|
+
"work-items": "work-items";
|
|
8123
|
+
"owner-ask": "owner-ask";
|
|
6620
8124
|
}>;
|
|
6621
8125
|
target: z.ZodString;
|
|
6622
8126
|
pageKey: z.ZodOptional<z.ZodString>;
|
|
@@ -6633,6 +8137,8 @@ export declare const ConfirmationView: z.ZodObject<{
|
|
|
6633
8137
|
"step-run": "step-run";
|
|
6634
8138
|
"ai-model": "ai-model";
|
|
6635
8139
|
"ai-test": "ai-test";
|
|
8140
|
+
"work-items": "work-items";
|
|
8141
|
+
"owner-ask": "owner-ask";
|
|
6636
8142
|
}>;
|
|
6637
8143
|
target: z.ZodString;
|
|
6638
8144
|
expiresAt: z.ZodString;
|
|
@@ -6647,10 +8153,10 @@ export declare const ProposeRequest: z.ZodObject<{
|
|
|
6647
8153
|
scope: z.ZodEnum<{
|
|
6648
8154
|
"service-desk": "service-desk";
|
|
6649
8155
|
"org-pack": "org-pack";
|
|
8156
|
+
work: "work";
|
|
6650
8157
|
audit: "audit";
|
|
6651
8158
|
corrections: "corrections";
|
|
6652
8159
|
answers: "answers";
|
|
6653
|
-
work: "work";
|
|
6654
8160
|
"owner-answers": "owner-answers";
|
|
6655
8161
|
baseline: "baseline";
|
|
6656
8162
|
initiatives: "initiatives";
|
|
@@ -7700,6 +9206,19 @@ export declare const ReleasePrsRequest: z.ZodObject<{
|
|
|
7700
9206
|
/** 2.75.0 (seventh UX walk): tick (done) or untick a task in the change's tasks.md. */
|
|
7701
9207
|
export declare const TaskDoneRequest: z.ZodObject<{
|
|
7702
9208
|
done: z.ZodBoolean;
|
|
9209
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
9210
|
+
}, z.core.$strict>;
|
|
9211
|
+
/**
|
|
9212
|
+
* 3.3.0 (app-only audit): Set the upstream of the branch checked out to the same branch on a
|
|
9213
|
+
* remote (`<remote>/<branch>`), when Bring in what merged found it follows none.
|
|
9214
|
+
*/
|
|
9215
|
+
export declare const UpstreamRequest: z.ZodObject<{
|
|
9216
|
+
upstream: z.ZodString;
|
|
9217
|
+
}, z.core.$strict>;
|
|
9218
|
+
/** 3.3.0 (app-only audit): Build and raise PR; `raise` pushes and opens the PR (`task-pr`). */
|
|
9219
|
+
export declare const TaskBuildRequest: z.ZodObject<{
|
|
9220
|
+
raise: z.ZodOptional<z.ZodBoolean>;
|
|
9221
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7703
9222
|
}, z.core.$strict>;
|
|
7704
9223
|
/**
|
|
7705
9224
|
* 2.83.0 (ninth UX walk): name a change's owners per role from the change page (an empty list
|
|
@@ -7853,7 +9372,10 @@ export declare const SaveNotifyRequest: z.ZodObject<{
|
|
|
7853
9372
|
channel: z.ZodOptional<z.ZodString>;
|
|
7854
9373
|
}, z.core.$strict>;
|
|
7855
9374
|
/** ADR 0048: show the digest, or send it through the notify adapter (the click is the approval). */
|
|
7856
|
-
/**
|
|
9375
|
+
/**
|
|
9376
|
+
* 3.0.0 (ADR 0186): send needs the person's confirmation from the app (`digest-send`). 3.1.0
|
|
9377
|
+
* (review round 50): of the channel it posts to, GET /api/me's notify.to.
|
|
9378
|
+
*/
|
|
7857
9379
|
export declare const SendDigestRequest: z.ZodObject<{
|
|
7858
9380
|
send: z.ZodDefault<z.ZodBoolean>;
|
|
7859
9381
|
confirmation: z.ZodOptional<z.ZodString>;
|
|
@@ -7911,7 +9433,7 @@ export declare const InitiativeSavedView: z.ZodObject<{
|
|
|
7911
9433
|
/** ADR 0078: the questions in questions/, and the files that aren't valid questions. */
|
|
7912
9434
|
export declare const QuestionList: z.ZodObject<{
|
|
7913
9435
|
questions: z.ZodArray<z.ZodObject<{
|
|
7914
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
9436
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
7915
9437
|
id: z.ZodString;
|
|
7916
9438
|
askedBy: z.ZodObject<{
|
|
7917
9439
|
step: z.ZodString;
|
|
@@ -7947,6 +9469,21 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
7947
9469
|
delivery: "delivery";
|
|
7948
9470
|
analysis: "analysis";
|
|
7949
9471
|
}>>;
|
|
9472
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
9473
|
+
business: "business";
|
|
9474
|
+
delivery: "delivery";
|
|
9475
|
+
design: "design";
|
|
9476
|
+
}>>;
|
|
9477
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
9478
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
9479
|
+
product: "product";
|
|
9480
|
+
architecture: "architecture";
|
|
9481
|
+
delivery: "delivery";
|
|
9482
|
+
analysis: "analysis";
|
|
9483
|
+
}>>;
|
|
9484
|
+
by: z.ZodString;
|
|
9485
|
+
at: z.ZodISODateTime;
|
|
9486
|
+
}, z.core.$strict>>;
|
|
7950
9487
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
7951
9488
|
finding: z.ZodOptional<z.ZodObject<{
|
|
7952
9489
|
change: z.ZodString;
|
|
@@ -8107,6 +9644,11 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
8107
9644
|
delivery: "delivery";
|
|
8108
9645
|
analysis: "analysis";
|
|
8109
9646
|
}>>;
|
|
9647
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
9648
|
+
business: "business";
|
|
9649
|
+
delivery: "delivery";
|
|
9650
|
+
design: "design";
|
|
9651
|
+
}>>;
|
|
8110
9652
|
proposal: z.ZodOptional<z.ZodObject<{
|
|
8111
9653
|
answer: z.ZodObject<{
|
|
8112
9654
|
option: z.ZodOptional<z.ZodNumber>;
|
|
@@ -8165,7 +9707,7 @@ export declare const AnswerQuestionRequest: z.ZodObject<{
|
|
|
8165
9707
|
/** ADR 0078: the answered question, the command to run next and, for a repo type, its skill file. */
|
|
8166
9708
|
export declare const AnsweredQuestion: z.ZodObject<{
|
|
8167
9709
|
question: z.ZodObject<{
|
|
8168
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
9710
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
8169
9711
|
id: z.ZodString;
|
|
8170
9712
|
askedBy: z.ZodObject<{
|
|
8171
9713
|
step: z.ZodString;
|
|
@@ -8201,6 +9743,21 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
8201
9743
|
delivery: "delivery";
|
|
8202
9744
|
analysis: "analysis";
|
|
8203
9745
|
}>>;
|
|
9746
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
9747
|
+
business: "business";
|
|
9748
|
+
delivery: "delivery";
|
|
9749
|
+
design: "design";
|
|
9750
|
+
}>>;
|
|
9751
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
9752
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
9753
|
+
product: "product";
|
|
9754
|
+
architecture: "architecture";
|
|
9755
|
+
delivery: "delivery";
|
|
9756
|
+
analysis: "analysis";
|
|
9757
|
+
}>>;
|
|
9758
|
+
by: z.ZodString;
|
|
9759
|
+
at: z.ZodISODateTime;
|
|
9760
|
+
}, z.core.$strict>>;
|
|
8204
9761
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
8205
9762
|
finding: z.ZodOptional<z.ZodObject<{
|
|
8206
9763
|
change: z.ZodString;
|
|
@@ -10121,17 +11678,211 @@ export declare const QuestionsProposeView: z.ZodObject<{
|
|
|
10121
11678
|
prompt: z.ZodOptional<z.ZodString>;
|
|
10122
11679
|
done: z.ZodOptional<z.ZodString>;
|
|
10123
11680
|
}, z.core.$strip>;
|
|
10124
|
-
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
10125
|
-
export declare const UpgradeView: z.ZodObject<{
|
|
10126
|
-
atticus: z.ZodString;
|
|
10127
|
-
newer: z.ZodBoolean;
|
|
10128
|
-
stamp: z.ZodOptional<z.ZodString>;
|
|
10129
|
-
pending: z.ZodArray<z.ZodObject<{
|
|
11681
|
+
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
11682
|
+
export declare const UpgradeView: z.ZodObject<{
|
|
11683
|
+
atticus: z.ZodString;
|
|
11684
|
+
newer: z.ZodBoolean;
|
|
11685
|
+
stamp: z.ZodOptional<z.ZodString>;
|
|
11686
|
+
pending: z.ZodArray<z.ZodObject<{
|
|
11687
|
+
id: z.ZodString;
|
|
11688
|
+
summary: z.ZodString;
|
|
11689
|
+
files: z.ZodArray<z.ZodString>;
|
|
11690
|
+
}, z.core.$strip>>;
|
|
11691
|
+
}, z.core.$strip>;
|
|
11692
|
+
/**
|
|
11693
|
+
* 3.5.0: what a setup edit changed, or with `preview: true` would change: the file
|
|
11694
|
+
* (metarepo-relative), its lines (what each was, none when added; what it is now, none when
|
|
11695
|
+
* removed), whether it was written, and what to do next (Propose).
|
|
11696
|
+
*/
|
|
11697
|
+
export declare const FileEditView: z.ZodObject<{
|
|
11698
|
+
path: z.ZodString;
|
|
11699
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
11700
|
+
was: z.ZodOptional<z.ZodString>;
|
|
11701
|
+
now: z.ZodOptional<z.ZodString>;
|
|
11702
|
+
}, z.core.$strip>>;
|
|
11703
|
+
written: z.ZodBoolean;
|
|
11704
|
+
note: z.ZodString;
|
|
11705
|
+
confirm: z.ZodOptional<z.ZodLiteral<"ai-model">>;
|
|
11706
|
+
}, z.core.$strip>;
|
|
11707
|
+
/** GET /api/setup/metarepo: whether this folder is a metarepo, and what Create would use. */
|
|
11708
|
+
export declare const SetupMetarepoView: z.ZodObject<{
|
|
11709
|
+
metarepo: z.ZodBoolean;
|
|
11710
|
+
root: z.ZodString;
|
|
11711
|
+
folder: z.ZodString;
|
|
11712
|
+
suggested: z.ZodObject<{
|
|
11713
|
+
name: z.ZodString;
|
|
11714
|
+
platform: z.ZodString;
|
|
11715
|
+
}, z.core.$strip>;
|
|
11716
|
+
origin: z.ZodOptional<z.ZodString>;
|
|
11717
|
+
metarepoId: z.ZodOptional<z.ZodString>;
|
|
11718
|
+
}, z.core.$strip>;
|
|
11719
|
+
export declare const CreateMetarepoRequest: z.ZodObject<{
|
|
11720
|
+
name: z.ZodString;
|
|
11721
|
+
platform: z.ZodString;
|
|
11722
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
11723
|
+
metarepo: z.ZodOptional<z.ZodString>;
|
|
11724
|
+
}, z.core.$strict>;
|
|
11725
|
+
export declare const OpenFolderRequest: z.ZodObject<{
|
|
11726
|
+
path: z.ZodString;
|
|
11727
|
+
}, z.core.$strict>;
|
|
11728
|
+
export declare const OpenFolderView: z.ZodObject<{
|
|
11729
|
+
url: z.ZodString;
|
|
11730
|
+
root: z.ZodString;
|
|
11731
|
+
metarepo: z.ZodBoolean;
|
|
11732
|
+
}, z.core.$strip>;
|
|
11733
|
+
/** Repos to add: pasted clone URLs (one a line), or a folder of clones (repos discover's code). */
|
|
11734
|
+
export declare const ReposPlanRequest: z.ZodObject<{
|
|
11735
|
+
urls: z.ZodOptional<z.ZodString>;
|
|
11736
|
+
dir: z.ZodOptional<z.ZodString>;
|
|
11737
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
11738
|
+
}, z.core.$strict>;
|
|
11739
|
+
export declare const PlannedRepoView: z.ZodObject<{
|
|
11740
|
+
id: z.ZodString;
|
|
11741
|
+
url: z.ZodString;
|
|
11742
|
+
given: z.ZodOptional<z.ZodString>;
|
|
11743
|
+
type: z.ZodString;
|
|
11744
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
11745
|
+
renamed: z.ZodOptional<z.ZodObject<{
|
|
11746
|
+
from: z.ZodString;
|
|
11747
|
+
why: z.ZodString;
|
|
11748
|
+
}, z.core.$strip>>;
|
|
11749
|
+
detected: z.ZodOptional<z.ZodObject<{
|
|
11750
|
+
signals: z.ZodArray<z.ZodString>;
|
|
11751
|
+
confidence: z.ZodString;
|
|
11752
|
+
}, z.core.$strip>>;
|
|
11753
|
+
}, z.core.$strip>;
|
|
11754
|
+
export declare const ReposPlanView: z.ZodObject<{
|
|
11755
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
11756
|
+
platforms: z.ZodArray<z.ZodString>;
|
|
11757
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
11758
|
+
id: z.ZodString;
|
|
11759
|
+
url: z.ZodString;
|
|
11760
|
+
given: z.ZodOptional<z.ZodString>;
|
|
11761
|
+
type: z.ZodString;
|
|
11762
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
11763
|
+
renamed: z.ZodOptional<z.ZodObject<{
|
|
11764
|
+
from: z.ZodString;
|
|
11765
|
+
why: z.ZodString;
|
|
11766
|
+
}, z.core.$strip>>;
|
|
11767
|
+
detected: z.ZodOptional<z.ZodObject<{
|
|
11768
|
+
signals: z.ZodArray<z.ZodString>;
|
|
11769
|
+
confidence: z.ZodString;
|
|
11770
|
+
}, z.core.$strip>>;
|
|
11771
|
+
}, z.core.$strip>>;
|
|
11772
|
+
listed: z.ZodArray<z.ZodObject<{
|
|
11773
|
+
url: z.ZodString;
|
|
11774
|
+
id: z.ZodString;
|
|
11775
|
+
}, z.core.$strip>>;
|
|
11776
|
+
refused: z.ZodArray<z.ZodObject<{
|
|
11777
|
+
given: z.ZodString;
|
|
11778
|
+
why: z.ZodString;
|
|
11779
|
+
}, z.core.$strip>>;
|
|
11780
|
+
skipped: z.ZodArray<z.ZodObject<{
|
|
11781
|
+
path: z.ZodString;
|
|
11782
|
+
reason: z.ZodString;
|
|
11783
|
+
}, z.core.$strip>>;
|
|
11784
|
+
}, z.core.$strip>;
|
|
11785
|
+
export declare const AddReposRequest: z.ZodObject<{
|
|
11786
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
11787
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
10130
11788
|
id: z.ZodString;
|
|
10131
|
-
|
|
10132
|
-
|
|
11789
|
+
url: z.ZodString;
|
|
11790
|
+
type: z.ZodOptional<z.ZodString>;
|
|
11791
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
11792
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
11793
|
+
description: z.ZodOptional<z.ZodString>;
|
|
11794
|
+
}, z.core.$strict>>;
|
|
11795
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11796
|
+
}, z.core.$strict>;
|
|
11797
|
+
export declare const RepoTypeDetectView: z.ZodObject<{
|
|
11798
|
+
repo: z.ZodString;
|
|
11799
|
+
from: z.ZodEnum<{
|
|
11800
|
+
files: "files";
|
|
11801
|
+
"repo-types": "repo-types";
|
|
11802
|
+
}>;
|
|
11803
|
+
verdict: z.ZodString;
|
|
11804
|
+
type: z.ZodOptional<z.ZodString>;
|
|
11805
|
+
signals: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
11806
|
+
confidence: z.ZodOptional<z.ZodString>;
|
|
11807
|
+
matches: z.ZodArray<z.ZodObject<{
|
|
11808
|
+
type: z.ZodString;
|
|
11809
|
+
name: z.ZodString;
|
|
11810
|
+
score: z.ZodNumber;
|
|
11811
|
+
}, z.core.$strip>>;
|
|
11812
|
+
}, z.core.$strip>;
|
|
11813
|
+
export declare const RepoTypeRequest: z.ZodObject<{
|
|
11814
|
+
type: z.ZodString;
|
|
11815
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11816
|
+
}, z.core.$strict>;
|
|
11817
|
+
export declare const AdaptersView: z.ZodObject<{
|
|
11818
|
+
path: z.ZodString;
|
|
11819
|
+
sha256: z.ZodString;
|
|
11820
|
+
kinds: z.ZodArray<z.ZodObject<{
|
|
11821
|
+
kind: z.ZodString;
|
|
11822
|
+
types: z.ZodArray<z.ZodString>;
|
|
11823
|
+
fields: z.ZodArray<z.ZodObject<{
|
|
11824
|
+
name: z.ZodString;
|
|
11825
|
+
list: z.ZodBoolean;
|
|
11826
|
+
}, z.core.$strip>>;
|
|
11827
|
+
current: z.ZodNullable<z.ZodObject<{
|
|
11828
|
+
type: z.ZodString;
|
|
11829
|
+
settings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
|
|
11830
|
+
}, z.core.$strip>>;
|
|
10133
11831
|
}, z.core.$strip>>;
|
|
11832
|
+
problems: z.ZodArray<z.ZodString>;
|
|
11833
|
+
}, z.core.$strip>;
|
|
11834
|
+
export declare const AdapterRequest: z.ZodObject<{
|
|
11835
|
+
value: z.ZodNullable<z.ZodObject<{
|
|
11836
|
+
type: z.ZodString;
|
|
11837
|
+
settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
11838
|
+
}, z.core.$strict>>;
|
|
11839
|
+
baseSha256: z.ZodOptional<z.ZodString>;
|
|
11840
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11841
|
+
}, z.core.$strict>;
|
|
11842
|
+
export declare const OrgPackFileView: z.ZodObject<{
|
|
11843
|
+
path: z.ZodString;
|
|
11844
|
+
rel: z.ZodString;
|
|
11845
|
+
content: z.ZodString;
|
|
11846
|
+
sha256: z.ZodString;
|
|
11847
|
+
exists: z.ZodBoolean;
|
|
11848
|
+
checked: z.ZodBoolean;
|
|
10134
11849
|
}, z.core.$strip>;
|
|
11850
|
+
export declare const OrgPackFileRequest: z.ZodObject<{
|
|
11851
|
+
path: z.ZodString;
|
|
11852
|
+
content: z.ZodString;
|
|
11853
|
+
baseSha256: z.ZodString;
|
|
11854
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11855
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
11856
|
+
}, z.core.$strict>;
|
|
11857
|
+
export declare const PatternRequest: z.ZodObject<{
|
|
11858
|
+
code: z.ZodString;
|
|
11859
|
+
name: z.ZodString;
|
|
11860
|
+
definition: z.ZodString;
|
|
11861
|
+
interaction: z.ZodString;
|
|
11862
|
+
route: z.ZodString;
|
|
11863
|
+
targetType: z.ZodString;
|
|
11864
|
+
controls: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
11865
|
+
source: z.ZodString;
|
|
11866
|
+
version: z.ZodOptional<z.ZodString>;
|
|
11867
|
+
status: z.ZodOptional<z.ZodString>;
|
|
11868
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11869
|
+
}, z.core.$strict>;
|
|
11870
|
+
export declare const SourceRequest: z.ZodObject<{
|
|
11871
|
+
type: z.ZodString;
|
|
11872
|
+
location: z.ZodString;
|
|
11873
|
+
id: z.ZodOptional<z.ZodString>;
|
|
11874
|
+
path: z.ZodOptional<z.ZodString>;
|
|
11875
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
11876
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
11877
|
+
}, z.core.$strict>;
|
|
11878
|
+
export type FileEditViewT = z.infer<typeof FileEditView>;
|
|
11879
|
+
export type SetupMetarepoViewT = z.infer<typeof SetupMetarepoView>;
|
|
11880
|
+
export type ReposPlanViewT = z.infer<typeof ReposPlanView>;
|
|
11881
|
+
export type PlannedRepoViewT = z.infer<typeof PlannedRepoView>;
|
|
11882
|
+
export type RepoTypeDetectViewT = z.infer<typeof RepoTypeDetectView>;
|
|
11883
|
+
export type AdaptersViewT = z.infer<typeof AdaptersView>;
|
|
11884
|
+
export type OrgPackFileViewT = z.infer<typeof OrgPackFileView>;
|
|
11885
|
+
export type OpenFolderViewT = z.infer<typeof OpenFolderView>;
|
|
10135
11886
|
export declare const ConnectLinksRequest: z.ZodObject<{
|
|
10136
11887
|
from: z.ZodString;
|
|
10137
11888
|
to: z.ZodObject<{
|
|
@@ -10238,6 +11989,7 @@ export declare const SketchStrokeRequest: z.ZodObject<{
|
|
|
10238
11989
|
kind: z.ZodEnum<{
|
|
10239
11990
|
table: "table";
|
|
10240
11991
|
call: "call";
|
|
11992
|
+
retire: "retire";
|
|
10241
11993
|
topic: "topic";
|
|
10242
11994
|
remove: "remove";
|
|
10243
11995
|
retarget: "retarget";
|
|
@@ -10569,210 +12321,815 @@ export declare const StartCopilotRunRequest: z.ZodObject<{
|
|
|
10569
12321
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10570
12322
|
force: z.ZodOptional<z.ZodBoolean>;
|
|
10571
12323
|
}, z.core.$strip>;
|
|
10572
|
-
export declare const CopilotRunState: z.ZodEnum<{
|
|
10573
|
-
done: "done";
|
|
10574
|
-
failed: "failed";
|
|
10575
|
-
running: "running";
|
|
10576
|
-
stopped: "stopped";
|
|
10577
|
-
}>;
|
|
10578
|
-
export declare const CopilotRunTab: z.ZodObject<{
|
|
12324
|
+
export declare const CopilotRunState: z.ZodEnum<{
|
|
12325
|
+
done: "done";
|
|
12326
|
+
failed: "failed";
|
|
12327
|
+
running: "running";
|
|
12328
|
+
stopped: "stopped";
|
|
12329
|
+
}>;
|
|
12330
|
+
export declare const CopilotRunTab: z.ZodObject<{
|
|
12331
|
+
id: z.ZodString;
|
|
12332
|
+
title: z.ZodString;
|
|
12333
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12334
|
+
state: z.ZodEnum<{
|
|
12335
|
+
failed: "failed";
|
|
12336
|
+
running: "running";
|
|
12337
|
+
ended: "ended";
|
|
12338
|
+
}>;
|
|
12339
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12340
|
+
from: z.ZodNumber;
|
|
12341
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12342
|
+
}, z.core.$strip>;
|
|
12343
|
+
export declare const CopilotRunView: z.ZodObject<{
|
|
12344
|
+
runId: z.ZodString;
|
|
12345
|
+
jobId: z.ZodString;
|
|
12346
|
+
kind: z.ZodEnum<{
|
|
12347
|
+
repos: "repos";
|
|
12348
|
+
stale: "stale";
|
|
12349
|
+
gaps: "gaps";
|
|
12350
|
+
all: "all";
|
|
12351
|
+
}>;
|
|
12352
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12353
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
12354
|
+
state: z.ZodEnum<{
|
|
12355
|
+
done: "done";
|
|
12356
|
+
failed: "failed";
|
|
12357
|
+
running: "running";
|
|
12358
|
+
stopped: "stopped";
|
|
12359
|
+
}>;
|
|
12360
|
+
by: z.ZodOptional<z.ZodString>;
|
|
12361
|
+
startedAt: z.ZodString;
|
|
12362
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12363
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12364
|
+
progress: z.ZodObject<{
|
|
12365
|
+
repos: z.ZodNumber;
|
|
12366
|
+
repoIndex: z.ZodNumber;
|
|
12367
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12368
|
+
session: z.ZodOptional<z.ZodString>;
|
|
12369
|
+
sessions: z.ZodNumber;
|
|
12370
|
+
}, z.core.$strip>;
|
|
12371
|
+
totals: z.ZodObject<{
|
|
12372
|
+
kept: z.ZodNumber;
|
|
12373
|
+
rejected: z.ZodNumber;
|
|
12374
|
+
tokens: z.ZodNumber;
|
|
12375
|
+
}, z.core.$strip>;
|
|
12376
|
+
message: z.ZodOptional<z.ZodString>;
|
|
12377
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
12378
|
+
id: z.ZodString;
|
|
12379
|
+
title: z.ZodString;
|
|
12380
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12381
|
+
state: z.ZodEnum<{
|
|
12382
|
+
failed: "failed";
|
|
12383
|
+
running: "running";
|
|
12384
|
+
ended: "ended";
|
|
12385
|
+
}>;
|
|
12386
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12387
|
+
from: z.ZodNumber;
|
|
12388
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12389
|
+
}, z.core.$strip>>;
|
|
12390
|
+
}, z.core.$strip>;
|
|
12391
|
+
export declare const CopilotRunCurrent: z.ZodObject<{
|
|
12392
|
+
run: z.ZodNullable<z.ZodObject<{
|
|
12393
|
+
runId: z.ZodString;
|
|
12394
|
+
jobId: z.ZodString;
|
|
12395
|
+
kind: z.ZodEnum<{
|
|
12396
|
+
repos: "repos";
|
|
12397
|
+
stale: "stale";
|
|
12398
|
+
gaps: "gaps";
|
|
12399
|
+
all: "all";
|
|
12400
|
+
}>;
|
|
12401
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12402
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
12403
|
+
state: z.ZodEnum<{
|
|
12404
|
+
done: "done";
|
|
12405
|
+
failed: "failed";
|
|
12406
|
+
running: "running";
|
|
12407
|
+
stopped: "stopped";
|
|
12408
|
+
}>;
|
|
12409
|
+
by: z.ZodOptional<z.ZodString>;
|
|
12410
|
+
startedAt: z.ZodString;
|
|
12411
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12412
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12413
|
+
progress: z.ZodObject<{
|
|
12414
|
+
repos: z.ZodNumber;
|
|
12415
|
+
repoIndex: z.ZodNumber;
|
|
12416
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12417
|
+
session: z.ZodOptional<z.ZodString>;
|
|
12418
|
+
sessions: z.ZodNumber;
|
|
12419
|
+
}, z.core.$strip>;
|
|
12420
|
+
totals: z.ZodObject<{
|
|
12421
|
+
kept: z.ZodNumber;
|
|
12422
|
+
rejected: z.ZodNumber;
|
|
12423
|
+
tokens: z.ZodNumber;
|
|
12424
|
+
}, z.core.$strip>;
|
|
12425
|
+
message: z.ZodOptional<z.ZodString>;
|
|
12426
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
12427
|
+
id: z.ZodString;
|
|
12428
|
+
title: z.ZodString;
|
|
12429
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12430
|
+
state: z.ZodEnum<{
|
|
12431
|
+
failed: "failed";
|
|
12432
|
+
running: "running";
|
|
12433
|
+
ended: "ended";
|
|
12434
|
+
}>;
|
|
12435
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12436
|
+
from: z.ZodNumber;
|
|
12437
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12438
|
+
}, z.core.$strip>>;
|
|
12439
|
+
}, z.core.$strip>>;
|
|
12440
|
+
allowed: z.ZodBoolean;
|
|
12441
|
+
why: z.ZodOptional<z.ZodString>;
|
|
12442
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12443
|
+
}, z.core.$strip>;
|
|
12444
|
+
export type CopilotRunKindT = z.infer<typeof CopilotRunKind>;
|
|
12445
|
+
export type StartCopilotRunRequestT = z.infer<typeof StartCopilotRunRequest>;
|
|
12446
|
+
export type CopilotRunStateT = z.infer<typeof CopilotRunState>;
|
|
12447
|
+
export type CopilotRunTabT = z.infer<typeof CopilotRunTab>;
|
|
12448
|
+
export type CopilotRunViewT = z.infer<typeof CopilotRunView>;
|
|
12449
|
+
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
12450
|
+
/** ADR 0187: one thing Atticus is doing or did on this metarepo, for the Console. */
|
|
12451
|
+
export declare const ActivityKind: z.ZodEnum<{
|
|
12452
|
+
local: "local";
|
|
12453
|
+
sync: "sync";
|
|
12454
|
+
index: "index";
|
|
12455
|
+
command: "command";
|
|
12456
|
+
step: "step";
|
|
12457
|
+
copilot: "copilot";
|
|
12458
|
+
scan: "scan";
|
|
12459
|
+
reconcile: "reconcile";
|
|
12460
|
+
intake: "intake";
|
|
12461
|
+
work: "work";
|
|
12462
|
+
handoff: "handoff";
|
|
12463
|
+
}>;
|
|
12464
|
+
export declare const ActivityState: z.ZodEnum<{
|
|
12465
|
+
done: "done";
|
|
12466
|
+
failed: "failed";
|
|
12467
|
+
running: "running";
|
|
12468
|
+
waiting: "waiting";
|
|
12469
|
+
cancelled: "cancelled";
|
|
12470
|
+
ended: "ended";
|
|
12471
|
+
}>;
|
|
12472
|
+
/** Where it was started. */
|
|
12473
|
+
export declare const ActivityWhere: z.ZodEnum<{
|
|
12474
|
+
assistant: "assistant";
|
|
12475
|
+
app: "app";
|
|
12476
|
+
copilot: "copilot";
|
|
12477
|
+
vscode: "vscode";
|
|
12478
|
+
intellij: "intellij";
|
|
12479
|
+
terminal: "terminal";
|
|
12480
|
+
}>;
|
|
12481
|
+
export declare const ActivityEntry: z.ZodObject<{
|
|
12482
|
+
id: z.ZodString;
|
|
12483
|
+
kind: z.ZodEnum<{
|
|
12484
|
+
local: "local";
|
|
12485
|
+
sync: "sync";
|
|
12486
|
+
index: "index";
|
|
12487
|
+
command: "command";
|
|
12488
|
+
step: "step";
|
|
12489
|
+
copilot: "copilot";
|
|
12490
|
+
scan: "scan";
|
|
12491
|
+
reconcile: "reconcile";
|
|
12492
|
+
intake: "intake";
|
|
12493
|
+
work: "work";
|
|
12494
|
+
handoff: "handoff";
|
|
12495
|
+
}>;
|
|
12496
|
+
title: z.ZodOptional<z.ZodString>;
|
|
12497
|
+
where: z.ZodEnum<{
|
|
12498
|
+
assistant: "assistant";
|
|
12499
|
+
app: "app";
|
|
12500
|
+
copilot: "copilot";
|
|
12501
|
+
vscode: "vscode";
|
|
12502
|
+
intellij: "intellij";
|
|
12503
|
+
terminal: "terminal";
|
|
12504
|
+
}>;
|
|
12505
|
+
state: z.ZodEnum<{
|
|
12506
|
+
done: "done";
|
|
12507
|
+
failed: "failed";
|
|
12508
|
+
running: "running";
|
|
12509
|
+
waiting: "waiting";
|
|
12510
|
+
cancelled: "cancelled";
|
|
12511
|
+
ended: "ended";
|
|
12512
|
+
}>;
|
|
12513
|
+
startedAt: z.ZodString;
|
|
12514
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12515
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
12516
|
+
done: z.ZodNumber;
|
|
12517
|
+
total: z.ZodNumber;
|
|
12518
|
+
message: z.ZodString;
|
|
12519
|
+
}, z.core.$strip>>;
|
|
12520
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
12521
|
+
lines: z.ZodNumber;
|
|
12522
|
+
from: z.ZodNumber;
|
|
12523
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
12524
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
12525
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
12526
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
12527
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
12528
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
12529
|
+
runId: z.ZodString;
|
|
12530
|
+
change: z.ZodString;
|
|
12531
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
12532
|
+
promptPath: z.ZodString;
|
|
12533
|
+
output: z.ZodOptional<z.ZodString>;
|
|
12534
|
+
}, z.core.$strip>>;
|
|
12535
|
+
}, z.core.$strip>;
|
|
12536
|
+
export declare const ActivityList: z.ZodObject<{
|
|
12537
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
12538
|
+
id: z.ZodString;
|
|
12539
|
+
kind: z.ZodEnum<{
|
|
12540
|
+
local: "local";
|
|
12541
|
+
sync: "sync";
|
|
12542
|
+
index: "index";
|
|
12543
|
+
command: "command";
|
|
12544
|
+
step: "step";
|
|
12545
|
+
copilot: "copilot";
|
|
12546
|
+
scan: "scan";
|
|
12547
|
+
reconcile: "reconcile";
|
|
12548
|
+
intake: "intake";
|
|
12549
|
+
work: "work";
|
|
12550
|
+
handoff: "handoff";
|
|
12551
|
+
}>;
|
|
12552
|
+
title: z.ZodOptional<z.ZodString>;
|
|
12553
|
+
where: z.ZodEnum<{
|
|
12554
|
+
assistant: "assistant";
|
|
12555
|
+
app: "app";
|
|
12556
|
+
copilot: "copilot";
|
|
12557
|
+
vscode: "vscode";
|
|
12558
|
+
intellij: "intellij";
|
|
12559
|
+
terminal: "terminal";
|
|
12560
|
+
}>;
|
|
12561
|
+
state: z.ZodEnum<{
|
|
12562
|
+
done: "done";
|
|
12563
|
+
failed: "failed";
|
|
12564
|
+
running: "running";
|
|
12565
|
+
waiting: "waiting";
|
|
12566
|
+
cancelled: "cancelled";
|
|
12567
|
+
ended: "ended";
|
|
12568
|
+
}>;
|
|
12569
|
+
startedAt: z.ZodString;
|
|
12570
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12571
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
12572
|
+
done: z.ZodNumber;
|
|
12573
|
+
total: z.ZodNumber;
|
|
12574
|
+
message: z.ZodString;
|
|
12575
|
+
}, z.core.$strip>>;
|
|
12576
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
12577
|
+
lines: z.ZodNumber;
|
|
12578
|
+
from: z.ZodNumber;
|
|
12579
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
12580
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
12581
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
12582
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
12583
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
12584
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
12585
|
+
runId: z.ZodString;
|
|
12586
|
+
change: z.ZodString;
|
|
12587
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
12588
|
+
promptPath: z.ZodString;
|
|
12589
|
+
output: z.ZodOptional<z.ZodString>;
|
|
12590
|
+
}, z.core.$strip>>;
|
|
12591
|
+
}, z.core.$strip>>;
|
|
12592
|
+
running: z.ZodNumber;
|
|
12593
|
+
}, z.core.$strip>;
|
|
12594
|
+
export declare const ActivityLines: z.ZodObject<{
|
|
10579
12595
|
id: z.ZodString;
|
|
10580
|
-
|
|
10581
|
-
|
|
12596
|
+
from: z.ZodNumber;
|
|
12597
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12598
|
+
total: z.ZodNumber;
|
|
10582
12599
|
state: z.ZodEnum<{
|
|
12600
|
+
done: "done";
|
|
10583
12601
|
failed: "failed";
|
|
10584
12602
|
running: "running";
|
|
12603
|
+
waiting: "waiting";
|
|
12604
|
+
cancelled: "cancelled";
|
|
10585
12605
|
ended: "ended";
|
|
10586
12606
|
}>;
|
|
10587
|
-
ended: z.ZodOptional<z.ZodString>;
|
|
10588
|
-
from: z.ZodNumber;
|
|
10589
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10590
12607
|
}, z.core.$strip>;
|
|
10591
|
-
export
|
|
10592
|
-
|
|
12608
|
+
export type ActivityKindT = z.infer<typeof ActivityKind>;
|
|
12609
|
+
export type ActivityStateT = z.infer<typeof ActivityState>;
|
|
12610
|
+
export type ActivityWhereT = z.infer<typeof ActivityWhere>;
|
|
12611
|
+
export type ActivityEntryT = z.infer<typeof ActivityEntry>;
|
|
12612
|
+
export type ActivityListT = z.infer<typeof ActivityList>;
|
|
12613
|
+
export type ActivityLinesT = z.infer<typeof ActivityLines>;
|
|
12614
|
+
/** Messages on the WebSocket at /api/events. */
|
|
12615
|
+
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
12616
|
+
type: z.ZodLiteral<"file.changed">;
|
|
12617
|
+
path: z.ZodString;
|
|
12618
|
+
catalog: z.ZodOptional<z.ZodBoolean>;
|
|
12619
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12620
|
+
type: z.ZodLiteral<"job.progress">;
|
|
12621
|
+
jobId: z.ZodString;
|
|
12622
|
+
done: z.ZodNumber;
|
|
12623
|
+
total: z.ZodNumber;
|
|
12624
|
+
message: z.ZodString;
|
|
12625
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12626
|
+
type: z.ZodLiteral<"job.done">;
|
|
10593
12627
|
jobId: z.ZodString;
|
|
10594
|
-
kind: z.ZodEnum<{
|
|
10595
|
-
repos: "repos";
|
|
10596
|
-
stale: "stale";
|
|
10597
|
-
gaps: "gaps";
|
|
10598
|
-
all: "all";
|
|
10599
|
-
}>;
|
|
10600
|
-
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10601
|
-
force: z.ZodOptional<z.ZodBoolean>;
|
|
10602
12628
|
state: z.ZodEnum<{
|
|
10603
12629
|
done: "done";
|
|
10604
12630
|
failed: "failed";
|
|
10605
12631
|
running: "running";
|
|
10606
|
-
|
|
12632
|
+
cancelled: "cancelled";
|
|
12633
|
+
queued: "queued";
|
|
10607
12634
|
}>;
|
|
10608
|
-
|
|
10609
|
-
|
|
10610
|
-
|
|
10611
|
-
|
|
10612
|
-
|
|
10613
|
-
|
|
10614
|
-
|
|
10615
|
-
|
|
10616
|
-
|
|
10617
|
-
|
|
10618
|
-
|
|
10619
|
-
|
|
10620
|
-
|
|
10621
|
-
|
|
10622
|
-
|
|
12635
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12636
|
+
type: z.ZodLiteral<"index.rebuilt">;
|
|
12637
|
+
records: z.ZodNumber;
|
|
12638
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12639
|
+
type: z.ZodLiteral<"run.changed">;
|
|
12640
|
+
runId: z.ZodString;
|
|
12641
|
+
state: z.ZodEnum<{
|
|
12642
|
+
failed: "failed";
|
|
12643
|
+
prepared: "prepared";
|
|
12644
|
+
waiting: "waiting";
|
|
12645
|
+
produced: "produced";
|
|
12646
|
+
validated: "validated";
|
|
12647
|
+
cancelled: "cancelled";
|
|
12648
|
+
}>;
|
|
12649
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12650
|
+
type: z.ZodLiteral<"copilot-run.state">;
|
|
12651
|
+
run: z.ZodObject<{
|
|
12652
|
+
message: z.ZodOptional<z.ZodString>;
|
|
12653
|
+
by: z.ZodOptional<z.ZodString>;
|
|
12654
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12655
|
+
kind: z.ZodEnum<{
|
|
12656
|
+
repos: "repos";
|
|
12657
|
+
stale: "stale";
|
|
12658
|
+
gaps: "gaps";
|
|
12659
|
+
all: "all";
|
|
12660
|
+
}>;
|
|
12661
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
12662
|
+
startedAt: z.ZodString;
|
|
12663
|
+
state: z.ZodEnum<{
|
|
12664
|
+
done: "done";
|
|
12665
|
+
failed: "failed";
|
|
12666
|
+
running: "running";
|
|
12667
|
+
stopped: "stopped";
|
|
12668
|
+
}>;
|
|
12669
|
+
runId: z.ZodString;
|
|
12670
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12671
|
+
progress: z.ZodObject<{
|
|
12672
|
+
repos: z.ZodNumber;
|
|
12673
|
+
repoIndex: z.ZodNumber;
|
|
12674
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12675
|
+
session: z.ZodOptional<z.ZodString>;
|
|
12676
|
+
sessions: z.ZodNumber;
|
|
12677
|
+
}, z.core.$strip>;
|
|
12678
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12679
|
+
jobId: z.ZodString;
|
|
12680
|
+
totals: z.ZodObject<{
|
|
12681
|
+
kept: z.ZodNumber;
|
|
12682
|
+
rejected: z.ZodNumber;
|
|
12683
|
+
tokens: z.ZodNumber;
|
|
12684
|
+
}, z.core.$strip>;
|
|
10623
12685
|
}, z.core.$strip>;
|
|
10624
|
-
|
|
10625
|
-
|
|
12686
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12687
|
+
type: z.ZodLiteral<"copilot-run.lines">;
|
|
12688
|
+
runId: z.ZodString;
|
|
12689
|
+
tab: z.ZodString;
|
|
12690
|
+
title: z.ZodString;
|
|
12691
|
+
at: z.ZodNumber;
|
|
12692
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12693
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12694
|
+
type: z.ZodLiteral<"activity.changed">;
|
|
12695
|
+
entry: z.ZodObject<{
|
|
10626
12696
|
id: z.ZodString;
|
|
12697
|
+
kind: z.ZodEnum<{
|
|
12698
|
+
local: "local";
|
|
12699
|
+
sync: "sync";
|
|
12700
|
+
index: "index";
|
|
12701
|
+
command: "command";
|
|
12702
|
+
step: "step";
|
|
12703
|
+
copilot: "copilot";
|
|
12704
|
+
scan: "scan";
|
|
12705
|
+
reconcile: "reconcile";
|
|
12706
|
+
intake: "intake";
|
|
12707
|
+
work: "work";
|
|
12708
|
+
handoff: "handoff";
|
|
12709
|
+
}>;
|
|
12710
|
+
title: z.ZodOptional<z.ZodString>;
|
|
12711
|
+
where: z.ZodEnum<{
|
|
12712
|
+
assistant: "assistant";
|
|
12713
|
+
app: "app";
|
|
12714
|
+
copilot: "copilot";
|
|
12715
|
+
vscode: "vscode";
|
|
12716
|
+
intellij: "intellij";
|
|
12717
|
+
terminal: "terminal";
|
|
12718
|
+
}>;
|
|
12719
|
+
state: z.ZodEnum<{
|
|
12720
|
+
done: "done";
|
|
12721
|
+
failed: "failed";
|
|
12722
|
+
running: "running";
|
|
12723
|
+
waiting: "waiting";
|
|
12724
|
+
cancelled: "cancelled";
|
|
12725
|
+
ended: "ended";
|
|
12726
|
+
}>;
|
|
12727
|
+
startedAt: z.ZodString;
|
|
12728
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12729
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
12730
|
+
done: z.ZodNumber;
|
|
12731
|
+
total: z.ZodNumber;
|
|
12732
|
+
message: z.ZodString;
|
|
12733
|
+
}, z.core.$strip>>;
|
|
12734
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
12735
|
+
lines: z.ZodNumber;
|
|
12736
|
+
from: z.ZodNumber;
|
|
12737
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
12738
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
12739
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
12740
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
12741
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
12742
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
12743
|
+
runId: z.ZodString;
|
|
12744
|
+
change: z.ZodString;
|
|
12745
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
12746
|
+
promptPath: z.ZodString;
|
|
12747
|
+
output: z.ZodOptional<z.ZodString>;
|
|
12748
|
+
}, z.core.$strip>>;
|
|
12749
|
+
}, z.core.$strip>;
|
|
12750
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12751
|
+
type: z.ZodLiteral<"activity.lines">;
|
|
12752
|
+
id: z.ZodString;
|
|
12753
|
+
at: z.ZodNumber;
|
|
12754
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12755
|
+
}, z.core.$strip>], "type">;
|
|
12756
|
+
/** 3.6.0 (ADR 0191): a person moves a question to another role. */
|
|
12757
|
+
export declare const RouteQuestionRequest: z.ZodObject<{
|
|
12758
|
+
role: z.ZodEnum<{
|
|
12759
|
+
product: "product";
|
|
12760
|
+
architecture: "architecture";
|
|
12761
|
+
delivery: "delivery";
|
|
12762
|
+
analysis: "analysis";
|
|
12763
|
+
}>;
|
|
12764
|
+
}, z.core.$strict>;
|
|
12765
|
+
/**
|
|
12766
|
+
* 3.6.0 (ADR 0191): the owners roles.yaml suggests for a change's roles: the team that owns its
|
|
12767
|
+
* repos (a team's `roles`), else the organisation's default for the role. Suggestions only: a
|
|
12768
|
+
* person accepts one with a click (PUT .../owners), nothing is written by itself. A role the
|
|
12769
|
+
* change already names is left out.
|
|
12770
|
+
*/
|
|
12771
|
+
export declare const OwnerSuggestion: z.ZodObject<{
|
|
12772
|
+
role: z.ZodString;
|
|
12773
|
+
people: z.ZodArray<z.ZodString>;
|
|
12774
|
+
from: z.ZodUnion<readonly [z.ZodObject<{
|
|
12775
|
+
team: z.ZodString;
|
|
12776
|
+
name: z.ZodOptional<z.ZodString>;
|
|
12777
|
+
repos: z.ZodArray<z.ZodString>;
|
|
12778
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12779
|
+
default: z.ZodLiteral<true>;
|
|
12780
|
+
}, z.core.$strip>]>;
|
|
12781
|
+
}, z.core.$strip>;
|
|
12782
|
+
export declare const OwnerSuggestionList: z.ZodObject<{
|
|
12783
|
+
change: z.ZodString;
|
|
12784
|
+
suggestions: z.ZodArray<z.ZodObject<{
|
|
12785
|
+
role: z.ZodString;
|
|
12786
|
+
people: z.ZodArray<z.ZodString>;
|
|
12787
|
+
from: z.ZodUnion<readonly [z.ZodObject<{
|
|
12788
|
+
team: z.ZodString;
|
|
12789
|
+
name: z.ZodOptional<z.ZodString>;
|
|
12790
|
+
repos: z.ZodArray<z.ZodString>;
|
|
12791
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
12792
|
+
default: z.ZodLiteral<true>;
|
|
12793
|
+
}, z.core.$strip>]>;
|
|
12794
|
+
}, z.core.$strip>>;
|
|
12795
|
+
note: z.ZodOptional<z.ZodString>;
|
|
12796
|
+
}, z.core.$strip>;
|
|
12797
|
+
export type OwnerSuggestionListT = z.infer<typeof OwnerSuggestionList>;
|
|
12798
|
+
/** 3.6.0 (ADR 0191): who a change waits on now, by role, with their names. */
|
|
12799
|
+
export declare const WaitsOn: z.ZodObject<{
|
|
12800
|
+
role: z.ZodString;
|
|
12801
|
+
people: z.ZodArray<z.ZodString>;
|
|
12802
|
+
because: z.ZodEnum<{
|
|
12803
|
+
phase: "phase";
|
|
12804
|
+
handoff: "handoff";
|
|
12805
|
+
}>;
|
|
12806
|
+
phase: z.ZodString;
|
|
12807
|
+
}, z.core.$strip>;
|
|
12808
|
+
export type WaitsOnT = z.infer<typeof WaitsOn>;
|
|
12809
|
+
/** 3.6.0 (ADR 0191): a critic finding with the level of what it asks (business, design, delivery). */
|
|
12810
|
+
export declare const FindingView: z.ZodObject<{
|
|
12811
|
+
asks: z.ZodEnum<{
|
|
12812
|
+
business: "business";
|
|
12813
|
+
delivery: "delivery";
|
|
12814
|
+
design: "design";
|
|
12815
|
+
}>;
|
|
12816
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
12817
|
+
id: z.ZodString;
|
|
12818
|
+
kind: z.ZodEnum<{
|
|
12819
|
+
issue: "issue";
|
|
12820
|
+
"knowledge-gap": "knowledge-gap";
|
|
12821
|
+
}>;
|
|
12822
|
+
change: z.ZodString;
|
|
12823
|
+
gate: z.ZodString;
|
|
12824
|
+
round: z.ZodNumber;
|
|
12825
|
+
rule: z.ZodString;
|
|
12826
|
+
layer: z.ZodEnum<{
|
|
12827
|
+
team: "team";
|
|
12828
|
+
constitution: "constitution";
|
|
12829
|
+
org: "org";
|
|
12830
|
+
}>;
|
|
12831
|
+
lens: z.ZodEnum<{
|
|
12832
|
+
release: "release";
|
|
12833
|
+
true: "true";
|
|
12834
|
+
complete: "complete";
|
|
12835
|
+
safe: "safe";
|
|
12836
|
+
ship: "ship";
|
|
12837
|
+
business: "business";
|
|
12838
|
+
architecture: "architecture";
|
|
12839
|
+
story: "story";
|
|
12840
|
+
ux: "ux";
|
|
12841
|
+
delivery: "delivery";
|
|
12842
|
+
"code-and-test": "code-and-test";
|
|
12843
|
+
}>;
|
|
12844
|
+
severity: z.ZodEnum<{
|
|
12845
|
+
blocking: "blocking";
|
|
12846
|
+
gap: "gap";
|
|
12847
|
+
risk: "risk";
|
|
12848
|
+
idea: "idea";
|
|
12849
|
+
}>;
|
|
12850
|
+
artifact: z.ZodString;
|
|
12851
|
+
locator: z.ZodObject<{
|
|
12852
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
12853
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
12854
|
+
record: z.ZodOptional<z.ZodString>;
|
|
12855
|
+
field: z.ZodOptional<z.ZodString>;
|
|
12856
|
+
}, z.core.$strict>;
|
|
12857
|
+
summary: z.ZodString;
|
|
12858
|
+
why: z.ZodString;
|
|
12859
|
+
fix: z.ZodObject<{
|
|
12860
|
+
text: z.ZodString;
|
|
12861
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
12862
|
+
}, z.core.$strict>;
|
|
12863
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
12864
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
12865
|
+
code: "code";
|
|
12866
|
+
config: "config";
|
|
12867
|
+
spec: "spec";
|
|
12868
|
+
gateway: "gateway";
|
|
12869
|
+
"event-config": "event-config";
|
|
12870
|
+
infrastructure: "infrastructure";
|
|
12871
|
+
pipeline: "pipeline";
|
|
12872
|
+
migration: "migration";
|
|
12873
|
+
diagram: "diagram";
|
|
12874
|
+
document: "document";
|
|
12875
|
+
export: "export";
|
|
12876
|
+
manual: "manual";
|
|
12877
|
+
}>, z.ZodEnum<{
|
|
12878
|
+
catalog: "catalog";
|
|
12879
|
+
artifact: "artifact";
|
|
12880
|
+
rule: "rule";
|
|
12881
|
+
}>]>;
|
|
12882
|
+
record: z.ZodOptional<z.ZodString>;
|
|
12883
|
+
path: z.ZodOptional<z.ZodString>;
|
|
12884
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12885
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
12886
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
12887
|
+
}, z.core.$strict>>;
|
|
12888
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
12889
|
+
text: z.ZodString;
|
|
12890
|
+
owner: z.ZodString;
|
|
12891
|
+
}, z.core.$strict>>;
|
|
12892
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
12893
|
+
question: z.ZodString;
|
|
12894
|
+
quote: z.ZodString;
|
|
12895
|
+
}, z.core.$strict>>;
|
|
12896
|
+
waivable: z.ZodBoolean;
|
|
12897
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
12898
|
+
open: "open";
|
|
12899
|
+
applied: "applied";
|
|
12900
|
+
dismissed: "dismissed";
|
|
12901
|
+
waived: "waived";
|
|
12902
|
+
asked: "asked";
|
|
12903
|
+
}>>;
|
|
12904
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
12905
|
+
action: z.ZodEnum<{
|
|
12906
|
+
apply: "apply";
|
|
12907
|
+
"edit-and-apply": "edit-and-apply";
|
|
12908
|
+
"not-relevant": "not-relevant";
|
|
12909
|
+
waive: "waive";
|
|
12910
|
+
ask: "ask";
|
|
12911
|
+
}>;
|
|
12912
|
+
by: z.ZodString;
|
|
12913
|
+
at: z.ZodISODateTime;
|
|
12914
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
12915
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
12916
|
+
}, z.core.$strict>>;
|
|
12917
|
+
createdAt: z.ZodISODateTime;
|
|
12918
|
+
}, z.core.$strict>;
|
|
12919
|
+
/**
|
|
12920
|
+
* 3.6.0 (ADR 0191): the work items a change's plan puts in the work tracker, one per feature,
|
|
12921
|
+
* story and task, as sync.yaml remembers them. With a manual tracker each is a step for a person
|
|
12922
|
+
* (the fields to copy, and where to record the tracker's id); with a live one, a write the
|
|
12923
|
+
* person confirms (`work-items`).
|
|
12924
|
+
*/
|
|
12925
|
+
export declare const WorkItemPlan: z.ZodObject<{
|
|
12926
|
+
change: z.ZodString;
|
|
12927
|
+
tracker: z.ZodEnum<{
|
|
12928
|
+
manual: "manual";
|
|
12929
|
+
none: "none";
|
|
12930
|
+
live: "live";
|
|
12931
|
+
}>;
|
|
12932
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12933
|
+
key: z.ZodString;
|
|
12934
|
+
type: z.ZodString;
|
|
10627
12935
|
title: z.ZodString;
|
|
10628
|
-
|
|
10629
|
-
|
|
10630
|
-
|
|
10631
|
-
|
|
10632
|
-
|
|
12936
|
+
action: z.ZodEnum<{
|
|
12937
|
+
update: "update";
|
|
12938
|
+
create: "create";
|
|
12939
|
+
unchanged: "unchanged";
|
|
12940
|
+
orphaned: "orphaned";
|
|
10633
12941
|
}>;
|
|
10634
|
-
|
|
10635
|
-
|
|
10636
|
-
|
|
12942
|
+
id: z.ZodOptional<z.ZodString>;
|
|
12943
|
+
step: z.ZodOptional<z.ZodString>;
|
|
12944
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10637
12945
|
}, z.core.$strip>>;
|
|
12946
|
+
command: z.ZodString;
|
|
10638
12947
|
}, z.core.$strip>;
|
|
10639
|
-
export
|
|
10640
|
-
|
|
10641
|
-
|
|
10642
|
-
|
|
10643
|
-
|
|
10644
|
-
|
|
10645
|
-
|
|
10646
|
-
|
|
10647
|
-
|
|
10648
|
-
|
|
10649
|
-
|
|
10650
|
-
|
|
10651
|
-
state: z.ZodEnum<{
|
|
10652
|
-
done: "done";
|
|
10653
|
-
failed: "failed";
|
|
10654
|
-
running: "running";
|
|
10655
|
-
stopped: "stopped";
|
|
12948
|
+
export type WorkItemPlanT = z.infer<typeof WorkItemPlan>;
|
|
12949
|
+
export declare const WorkItemSyncRequest: z.ZodObject<{
|
|
12950
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
12951
|
+
job: z.ZodOptional<z.ZodBoolean>;
|
|
12952
|
+
}, z.core.$strict>;
|
|
12953
|
+
export declare const WorkItemSyncResult: z.ZodObject<{
|
|
12954
|
+
plan: z.ZodObject<{
|
|
12955
|
+
change: z.ZodString;
|
|
12956
|
+
tracker: z.ZodEnum<{
|
|
12957
|
+
manual: "manual";
|
|
12958
|
+
none: "none";
|
|
12959
|
+
live: "live";
|
|
10656
12960
|
}>;
|
|
10657
|
-
|
|
10658
|
-
|
|
10659
|
-
|
|
10660
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10661
|
-
progress: z.ZodObject<{
|
|
10662
|
-
repos: z.ZodNumber;
|
|
10663
|
-
repoIndex: z.ZodNumber;
|
|
10664
|
-
repo: z.ZodOptional<z.ZodString>;
|
|
10665
|
-
session: z.ZodOptional<z.ZodString>;
|
|
10666
|
-
sessions: z.ZodNumber;
|
|
10667
|
-
}, z.core.$strip>;
|
|
10668
|
-
totals: z.ZodObject<{
|
|
10669
|
-
kept: z.ZodNumber;
|
|
10670
|
-
rejected: z.ZodNumber;
|
|
10671
|
-
tokens: z.ZodNumber;
|
|
10672
|
-
}, z.core.$strip>;
|
|
10673
|
-
message: z.ZodOptional<z.ZodString>;
|
|
10674
|
-
tabs: z.ZodArray<z.ZodObject<{
|
|
10675
|
-
id: z.ZodString;
|
|
12961
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12962
|
+
key: z.ZodString;
|
|
12963
|
+
type: z.ZodString;
|
|
10676
12964
|
title: z.ZodString;
|
|
10677
|
-
|
|
10678
|
-
|
|
10679
|
-
|
|
10680
|
-
|
|
10681
|
-
|
|
12965
|
+
action: z.ZodEnum<{
|
|
12966
|
+
update: "update";
|
|
12967
|
+
create: "create";
|
|
12968
|
+
unchanged: "unchanged";
|
|
12969
|
+
orphaned: "orphaned";
|
|
10682
12970
|
}>;
|
|
10683
|
-
|
|
10684
|
-
|
|
10685
|
-
|
|
12971
|
+
id: z.ZodOptional<z.ZodString>;
|
|
12972
|
+
step: z.ZodOptional<z.ZodString>;
|
|
12973
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10686
12974
|
}, z.core.$strip>>;
|
|
12975
|
+
command: z.ZodString;
|
|
12976
|
+
}, z.core.$strip>;
|
|
12977
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12978
|
+
done: z.ZodArray<z.ZodObject<{
|
|
12979
|
+
key: z.ZodString;
|
|
12980
|
+
action: z.ZodString;
|
|
12981
|
+
id: z.ZodString;
|
|
10687
12982
|
}, z.core.$strip>>;
|
|
10688
|
-
|
|
12983
|
+
failed: z.ZodArray<z.ZodObject<{
|
|
12984
|
+
key: z.ZodString;
|
|
12985
|
+
reason: z.ZodString;
|
|
12986
|
+
}, z.core.$strip>>;
|
|
12987
|
+
}, z.core.$strip>;
|
|
12988
|
+
export type WorkItemSyncResultT = z.infer<typeof WorkItemSyncResult>;
|
|
12989
|
+
/**
|
|
12990
|
+
* 3.6.0 (ADR 0191): send an owner question through the configured notifications adapter, on the
|
|
12991
|
+
* person's confirmation (`owner-ask`, target the question's id). With manual notifications it is
|
|
12992
|
+
* a step for a person, as before.
|
|
12993
|
+
*/
|
|
12994
|
+
export declare const SendOwnerAskRequest: z.ZodObject<{
|
|
12995
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
12996
|
+
}, z.core.$strict>;
|
|
12997
|
+
export declare const SentOwnerAsk: z.ZodObject<{
|
|
12998
|
+
state: z.ZodEnum<{
|
|
12999
|
+
sent: "sent";
|
|
13000
|
+
step: "step";
|
|
13001
|
+
"not-sent": "not-sent";
|
|
13002
|
+
}>;
|
|
13003
|
+
to: z.ZodString;
|
|
13004
|
+
id: z.ZodOptional<z.ZodString>;
|
|
10689
13005
|
why: z.ZodOptional<z.ZodString>;
|
|
10690
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10691
13006
|
}, z.core.$strip>;
|
|
10692
|
-
export type
|
|
10693
|
-
|
|
10694
|
-
export
|
|
10695
|
-
|
|
10696
|
-
|
|
10697
|
-
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
10698
|
-
/** Messages on the WebSocket at /api/events. */
|
|
10699
|
-
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
10700
|
-
type: z.ZodLiteral<"file.changed">;
|
|
13007
|
+
export type SentOwnerAskT = z.infer<typeof SentOwnerAsk>;
|
|
13008
|
+
/** 3.6.0 (ADR 0191): a passage of the org's wikis or inputs/ files, with where it is. */
|
|
13009
|
+
export declare const KnowledgePassageView: z.ZodObject<{
|
|
13010
|
+
source: z.ZodString;
|
|
13011
|
+
page: z.ZodString;
|
|
10701
13012
|
path: z.ZodString;
|
|
10702
|
-
|
|
10703
|
-
|
|
10704
|
-
|
|
10705
|
-
|
|
10706
|
-
|
|
10707
|
-
|
|
10708
|
-
|
|
10709
|
-
|
|
10710
|
-
|
|
10711
|
-
|
|
10712
|
-
|
|
10713
|
-
|
|
10714
|
-
|
|
10715
|
-
|
|
10716
|
-
|
|
13013
|
+
heading: z.ZodString;
|
|
13014
|
+
line: z.ZodNumber;
|
|
13015
|
+
text: z.ZodString;
|
|
13016
|
+
}, z.core.$strip>;
|
|
13017
|
+
export type KnowledgePassageViewT = z.infer<typeof KnowledgePassageView>;
|
|
13018
|
+
/**
|
|
13019
|
+
* 3.6.0 (ADR 0191): what the organisation's knowledge says to a question, found by its words (no
|
|
13020
|
+
* AI): the knowledge items it matches, each with the quote it rests on, and the passages of the
|
|
13021
|
+
* wikis' snapshots and inputs/ files. Nothing is made up: each shows where it is from.
|
|
13022
|
+
*/
|
|
13023
|
+
export declare const KnowledgeAnswerView: z.ZodObject<{
|
|
13024
|
+
items: z.ZodArray<z.ZodObject<{
|
|
13025
|
+
id: z.ZodString;
|
|
13026
|
+
kind: z.ZodString;
|
|
13027
|
+
title: z.ZodString;
|
|
13028
|
+
quote: z.ZodOptional<z.ZodObject<{
|
|
13029
|
+
source: z.ZodString;
|
|
13030
|
+
page: z.ZodString;
|
|
13031
|
+
section: z.ZodOptional<z.ZodString>;
|
|
13032
|
+
text: z.ZodString;
|
|
13033
|
+
}, z.core.$strip>>;
|
|
13034
|
+
}, z.core.$strip>>;
|
|
13035
|
+
passages: z.ZodArray<z.ZodObject<{
|
|
13036
|
+
source: z.ZodString;
|
|
13037
|
+
page: z.ZodString;
|
|
13038
|
+
path: z.ZodString;
|
|
13039
|
+
heading: z.ZodString;
|
|
13040
|
+
line: z.ZodNumber;
|
|
13041
|
+
text: z.ZodString;
|
|
13042
|
+
}, z.core.$strip>>;
|
|
13043
|
+
command: z.ZodString;
|
|
13044
|
+
}, z.core.$strip>;
|
|
13045
|
+
export type KnowledgeAnswerViewT = z.infer<typeof KnowledgeAnswerView>;
|
|
13046
|
+
/**
|
|
13047
|
+
* 3.6.0 (ADR 0191): the business analyst's shaping of a change's stories, in plain words. A
|
|
13048
|
+
* rename keeps the story's number; a split's first part keeps it and each other part gets the next
|
|
13049
|
+
* free one; a merge keeps the first story's; an added story gets the next free one. The AI maps
|
|
13050
|
+
* the tasks to the stories at the next draft, and the critic checks none is left without a story.
|
|
13051
|
+
*/
|
|
13052
|
+
export declare const StoryShapeOp: z.ZodEnum<{
|
|
13053
|
+
split: "split";
|
|
13054
|
+
add: "add";
|
|
13055
|
+
merge: "merge";
|
|
13056
|
+
rename: "rename";
|
|
13057
|
+
}>;
|
|
13058
|
+
export declare const StoryShapeRequest: z.ZodObject<{
|
|
13059
|
+
op: z.ZodEnum<{
|
|
13060
|
+
split: "split";
|
|
13061
|
+
add: "add";
|
|
13062
|
+
merge: "merge";
|
|
13063
|
+
rename: "rename";
|
|
10717
13064
|
}>;
|
|
10718
|
-
|
|
10719
|
-
|
|
10720
|
-
|
|
10721
|
-
|
|
10722
|
-
|
|
10723
|
-
|
|
13065
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13066
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13067
|
+
name: z.ZodString;
|
|
13068
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13069
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13070
|
+
name: z.ZodString;
|
|
13071
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13072
|
+
}, z.core.$strict>>>;
|
|
13073
|
+
}, z.core.$strict>;
|
|
13074
|
+
export declare const StoryShapeEntryView: z.ZodObject<{
|
|
13075
|
+
id: z.ZodString;
|
|
13076
|
+
op: z.ZodEnum<{
|
|
13077
|
+
split: "split";
|
|
13078
|
+
add: "add";
|
|
13079
|
+
merge: "merge";
|
|
13080
|
+
rename: "rename";
|
|
13081
|
+
}>;
|
|
13082
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13083
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13084
|
+
name: z.ZodString;
|
|
13085
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13086
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13087
|
+
id: z.ZodString;
|
|
13088
|
+
name: z.ZodString;
|
|
13089
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13090
|
+
}, z.core.$strip>>>;
|
|
13091
|
+
added: z.ZodOptional<z.ZodString>;
|
|
13092
|
+
by: z.ZodString;
|
|
13093
|
+
at: z.ZodString;
|
|
10724
13094
|
state: z.ZodEnum<{
|
|
10725
|
-
|
|
10726
|
-
prepared: "prepared";
|
|
13095
|
+
applied: "applied";
|
|
10727
13096
|
waiting: "waiting";
|
|
10728
|
-
produced: "produced";
|
|
10729
|
-
validated: "validated";
|
|
10730
|
-
cancelled: "cancelled";
|
|
10731
13097
|
}>;
|
|
10732
|
-
|
|
10733
|
-
|
|
10734
|
-
|
|
10735
|
-
|
|
10736
|
-
|
|
10737
|
-
|
|
10738
|
-
|
|
10739
|
-
|
|
10740
|
-
|
|
10741
|
-
|
|
10742
|
-
|
|
13098
|
+
run: z.ZodOptional<z.ZodString>;
|
|
13099
|
+
}, z.core.$strip>;
|
|
13100
|
+
export declare const StoryShapeView: z.ZodObject<{
|
|
13101
|
+
change: z.ZodString;
|
|
13102
|
+
file: z.ZodString;
|
|
13103
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
13104
|
+
id: z.ZodString;
|
|
13105
|
+
op: z.ZodEnum<{
|
|
13106
|
+
split: "split";
|
|
13107
|
+
add: "add";
|
|
13108
|
+
merge: "merge";
|
|
13109
|
+
rename: "rename";
|
|
10743
13110
|
}>;
|
|
10744
|
-
|
|
10745
|
-
|
|
13111
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13112
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13113
|
+
name: z.ZodString;
|
|
13114
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13115
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13116
|
+
id: z.ZodString;
|
|
13117
|
+
name: z.ZodString;
|
|
13118
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13119
|
+
}, z.core.$strip>>>;
|
|
13120
|
+
added: z.ZodOptional<z.ZodString>;
|
|
13121
|
+
by: z.ZodString;
|
|
13122
|
+
at: z.ZodString;
|
|
10746
13123
|
state: z.ZodEnum<{
|
|
10747
|
-
|
|
10748
|
-
|
|
10749
|
-
running: "running";
|
|
10750
|
-
stopped: "stopped";
|
|
13124
|
+
applied: "applied";
|
|
13125
|
+
waiting: "waiting";
|
|
10751
13126
|
}>;
|
|
10752
|
-
|
|
10753
|
-
|
|
10754
|
-
|
|
10755
|
-
|
|
10756
|
-
|
|
10757
|
-
|
|
10758
|
-
|
|
10759
|
-
sessions: z.ZodNumber;
|
|
10760
|
-
}, z.core.$strip>;
|
|
10761
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10762
|
-
jobId: z.ZodString;
|
|
10763
|
-
totals: z.ZodObject<{
|
|
10764
|
-
kept: z.ZodNumber;
|
|
10765
|
-
rejected: z.ZodNumber;
|
|
10766
|
-
tokens: z.ZodNumber;
|
|
10767
|
-
}, z.core.$strip>;
|
|
10768
|
-
}, z.core.$strip>;
|
|
10769
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
10770
|
-
type: z.ZodLiteral<"copilot-run.lines">;
|
|
10771
|
-
runId: z.ZodString;
|
|
10772
|
-
tab: z.ZodString;
|
|
10773
|
-
title: z.ZodString;
|
|
10774
|
-
at: z.ZodNumber;
|
|
10775
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10776
|
-
}, z.core.$strip>], "type">;
|
|
13127
|
+
run: z.ZodOptional<z.ZodString>;
|
|
13128
|
+
}, z.core.$strip>>;
|
|
13129
|
+
assigned: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
13130
|
+
uncovered: z.ZodArray<z.ZodString>;
|
|
13131
|
+
command: z.ZodString;
|
|
13132
|
+
}, z.core.$strip>;
|
|
13133
|
+
export type StoryShapeViewT = z.infer<typeof StoryShapeView>;
|
|
10777
13134
|
/** Build the OpenAPI 3.1 document from the zod schemas. */
|
|
10778
13135
|
export declare function openApiDocument(): Record<string, unknown>;
|