@maycombhq/sdk 2.0.0-beta.21 → 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/ai-decisions.d.ts +14 -1
- package/npm/core/api.d.ts +2993 -550
- package/npm/core/cite.d.ts +20 -4
- package/npm/core/facts-carry.d.ts +8 -2
- package/npm/core/facts-join.d.ts +78 -1
- package/npm/core/fs.d.ts +25 -0
- package/npm/core/glob.d.ts +14 -0
- package/npm/core/identity.d.ts +28 -0
- package/npm/core/index.d.ts +6 -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 +19 -3
- package/npm/core/repo-files.d.ts +60 -0
- 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 +17 -3
- package/npm/core/schema/orgpack.d.ts +71 -18
- 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/fs-repo.d.ts +2 -1
- package/npm/index.js +1491 -110
- package/npm/listing.d.ts +14 -0
- package/package.json +1 -1
package/npm/core/api.d.ts
CHANGED
|
@@ -297,10 +297,150 @@ import { z } from "zod";
|
|
|
297
297
|
* as last applied. GET /api/settings/ai gives `decide` and `schemaVersion`, and PUT takes
|
|
298
298
|
* `decide` (lifting a version 3 file to 4). GET /api/upgrade lists the pending upgrade steps and
|
|
299
299
|
* POST /api/upgrade runs `atticus upgrade` as a local job on the person's click. Additive only.
|
|
300
|
+
* 3.0.0 (ADR 0186, review round 48: writes to shared systems need a person's confirmation). Not
|
|
301
|
+
* additive: the session token, which `--show-token` prints for assistants and scripts, is no
|
|
302
|
+
* longer a person's yes. POST /api/confirmations gives the app's page a confirmation for one
|
|
303
|
+
* write and target (single use, two minutes), and only with the page key the server puts in the
|
|
304
|
+
* page (<meta name="atticus-page-key">, or ATTICUS_UI_PAGE_KEY from the editor that starts it)
|
|
305
|
+
* and never prints. These take it as `confirmation` and answer 403 without a valid one: POST
|
|
306
|
+
* /api/changes/{changeId}/handoff (`handoff`), .../release-prs (`release-prs`),
|
|
307
|
+
* .../tasks/{taskId}/pr (`task-pr`, `<change>/<task>`), POST /api/propose (`propose`, the
|
|
308
|
+
* scope), POST /api/todo/{stepId}/run (`step-run`), POST /api/me/digest with send (`digest-send`,
|
|
309
|
+
* `me`), PUT /api/settings/ai when it changes the provider, keyEnv or an address (`ai-model`,
|
|
310
|
+
* `model`) and POST /api/settings/ai/test when the model settings differ from HEAD's (`ai-test`,
|
|
311
|
+
* `model`). POST .../sync merges a ready PR only with one (`merge`); without one it only reads.
|
|
312
|
+
* keyEnv must be a variable starting ATTICUS_, a model provider's own key variable or a name in
|
|
313
|
+
* the credential store (422). POST /api/workspace/sync and /api/reconcile answer 409 while one of
|
|
314
|
+
* their kind runs; GET /api/past-changes?change= and /api/changes/{changeId}/cockpit answer 400
|
|
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.
|
|
300
431
|
*/
|
|
301
|
-
export declare const API_VERSION = "
|
|
432
|
+
export declare const API_VERSION = "3.9.0";
|
|
302
433
|
export declare const DEFAULT_PORT = 4321;
|
|
303
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>;
|
|
304
444
|
export declare const Problem: z.ZodObject<{
|
|
305
445
|
type: z.ZodString;
|
|
306
446
|
title: z.ZodString;
|
|
@@ -314,6 +454,10 @@ export declare const Problem: z.ZodObject<{
|
|
|
314
454
|
role: z.ZodString;
|
|
315
455
|
names: z.ZodArray<z.ZodString>;
|
|
316
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>>;
|
|
317
461
|
}, z.core.$strip>;
|
|
318
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>>[]]>;
|
|
319
463
|
export declare const RecordPage: z.ZodObject<{
|
|
@@ -1317,6 +1461,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1317
1461
|
scan: "scan";
|
|
1318
1462
|
reconcile: "reconcile";
|
|
1319
1463
|
intake: "intake";
|
|
1464
|
+
work: "work";
|
|
1320
1465
|
}>;
|
|
1321
1466
|
state: z.ZodEnum<{
|
|
1322
1467
|
done: "done";
|
|
@@ -1330,6 +1475,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1330
1475
|
total: z.ZodNumber;
|
|
1331
1476
|
message: z.ZodString;
|
|
1332
1477
|
}, z.core.$strip>;
|
|
1478
|
+
title: z.ZodOptional<z.ZodString>;
|
|
1333
1479
|
startedAt: z.ZodString;
|
|
1334
1480
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
1335
1481
|
errors: z.ZodArray<z.ZodString>;
|
|
@@ -1403,6 +1549,12 @@ export declare const ChangeSummary: z.ZodObject<{
|
|
|
1403
1549
|
}, z.core.$strip>;
|
|
1404
1550
|
updatedAt: z.ZodString;
|
|
1405
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
|
+
}>>>;
|
|
1406
1558
|
}, z.core.$strip>;
|
|
1407
1559
|
export declare const ChangeDetail: z.ZodObject<{
|
|
1408
1560
|
id: z.ZodString;
|
|
@@ -1430,6 +1582,12 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1430
1582
|
}, z.core.$strip>;
|
|
1431
1583
|
updatedAt: z.ZodString;
|
|
1432
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
|
+
}>>>;
|
|
1433
1591
|
notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1434
1592
|
owners: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
|
|
1435
1593
|
artifacts: z.ZodArray<z.ZodObject<{
|
|
@@ -1508,6 +1666,8 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1508
1666
|
merged: "merged";
|
|
1509
1667
|
closed: "closed";
|
|
1510
1668
|
}>;
|
|
1669
|
+
unpushed: z.ZodOptional<z.ZodBoolean>;
|
|
1670
|
+
branch: z.ZodOptional<z.ZodString>;
|
|
1511
1671
|
}, z.core.$strip>>;
|
|
1512
1672
|
}, z.core.$strip>;
|
|
1513
1673
|
export declare const ArtifactContent: z.ZodObject<{
|
|
@@ -1562,6 +1722,16 @@ export declare const Task: z.ZodObject<{
|
|
|
1562
1722
|
tasks: z.ZodArray<z.ZodString>;
|
|
1563
1723
|
sameRepo: z.ZodArray<z.ZodString>;
|
|
1564
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>;
|
|
1565
1735
|
}, z.core.$strip>;
|
|
1566
1736
|
export type TaskT = z.infer<typeof Task>;
|
|
1567
1737
|
export declare const RunView: z.ZodObject<{
|
|
@@ -1795,6 +1965,14 @@ export declare const StartStepRequest: z.ZodObject<{
|
|
|
1795
1965
|
args: z.ZodArray<z.ZodString>;
|
|
1796
1966
|
}, z.core.$strip>;
|
|
1797
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>;
|
|
1798
1976
|
export declare const RunDoneView: z.ZodObject<{
|
|
1799
1977
|
schemaVersion: z.ZodLiteral<6>;
|
|
1800
1978
|
runId: z.ZodString;
|
|
@@ -1906,7 +2084,23 @@ export declare const RunDoneView: z.ZodObject<{
|
|
|
1906
2084
|
}, z.core.$strip>>;
|
|
1907
2085
|
lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1908
2086
|
next: z.ZodOptional<z.ZodString>;
|
|
2087
|
+
applied: z.ZodOptional<z.ZodString>;
|
|
1909
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>;
|
|
1910
2104
|
/** 2.66.0 (UX review): the step prepared for the person's own assistant, and its run. */
|
|
1911
2105
|
export declare const PreparedStepView: z.ZodObject<{
|
|
1912
2106
|
runId: z.ZodOptional<z.ZodString>;
|
|
@@ -3020,6 +3214,15 @@ export declare const ChangeKnowledgeItem: z.ZodObject<{
|
|
|
3020
3214
|
team: "team";
|
|
3021
3215
|
reference: "reference";
|
|
3022
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>>;
|
|
3023
3226
|
}, z.core.$strip>;
|
|
3024
3227
|
/**
|
|
3025
3228
|
* 2.26.0 (ADR 0124 addendum B-task-knowledge): pages that disagree about a knowledge item, what
|
|
@@ -3107,6 +3310,15 @@ export declare const ChangeKnowledgeView: z.ZodObject<{
|
|
|
3107
3310
|
team: "team";
|
|
3108
3311
|
reference: "reference";
|
|
3109
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>>;
|
|
3110
3322
|
}, z.core.$strip>>;
|
|
3111
3323
|
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3112
3324
|
id: z.ZodString;
|
|
@@ -3203,6 +3415,15 @@ export declare const SetChangeKnowledgeResult: z.ZodObject<{
|
|
|
3203
3415
|
team: "team";
|
|
3204
3416
|
reference: "reference";
|
|
3205
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>>;
|
|
3206
3427
|
}, z.core.$strip>>;
|
|
3207
3428
|
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3208
3429
|
id: z.ZodString;
|
|
@@ -4840,7 +5061,7 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4840
5061
|
}, z.core.$strip>>;
|
|
4841
5062
|
}, z.core.$strip>>;
|
|
4842
5063
|
questions: z.ZodArray<z.ZodObject<{
|
|
4843
|
-
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>]>;
|
|
4844
5065
|
id: z.ZodString;
|
|
4845
5066
|
askedBy: z.ZodObject<{
|
|
4846
5067
|
step: z.ZodString;
|
|
@@ -4876,6 +5097,21 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4876
5097
|
delivery: "delivery";
|
|
4877
5098
|
analysis: "analysis";
|
|
4878
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>>;
|
|
4879
5115
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
4880
5116
|
finding: z.ZodOptional<z.ZodObject<{
|
|
4881
5117
|
change: z.ZodString;
|
|
@@ -5049,381 +5285,133 @@ export declare const StageCommentResult: z.ZodObject<{
|
|
|
5049
5285
|
}, z.core.$strip>;
|
|
5050
5286
|
}, z.core.$strip>;
|
|
5051
5287
|
export type StageReviewViewT = z.infer<typeof StageReviewView>;
|
|
5052
|
-
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
5053
|
-
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
5054
5288
|
/**
|
|
5055
|
-
*
|
|
5056
|
-
*
|
|
5057
|
-
*
|
|
5058
|
-
*
|
|
5059
|
-
*
|
|
5060
|
-
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
5061
|
-
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
5062
|
-
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
5063
|
-
* 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.
|
|
5064
5294
|
*/
|
|
5065
|
-
export declare const
|
|
5066
|
-
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";
|
|
5067
5298
|
architecture: "architecture";
|
|
5299
|
+
proposal: "proposal";
|
|
5068
5300
|
stories: "stories";
|
|
5069
|
-
tasks: "tasks";
|
|
5070
5301
|
feature: "feature";
|
|
5071
5302
|
}>;
|
|
5072
|
-
export declare const
|
|
5073
|
-
|
|
5074
|
-
|
|
5075
|
-
|
|
5076
|
-
|
|
5077
|
-
|
|
5078
|
-
|
|
5079
|
-
|
|
5080
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5081
|
-
}, z.core.$strip>;
|
|
5082
|
-
export declare const DraftItemView: z.ZodObject<{
|
|
5083
|
-
id: z.ZodString;
|
|
5084
|
-
label: z.ZodString;
|
|
5085
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5086
|
-
}, z.core.$strip>;
|
|
5087
|
-
export declare const DraftFileView: z.ZodObject<{
|
|
5088
|
-
file: z.ZodString;
|
|
5089
|
-
path: z.ZodString;
|
|
5090
|
-
stage: z.ZodString;
|
|
5091
|
-
drafted: z.ZodOptional<z.ZodObject<{
|
|
5092
|
-
by: z.ZodEnum<{
|
|
5093
|
-
ai: "ai";
|
|
5094
|
-
person: "person";
|
|
5095
|
-
}>;
|
|
5096
|
-
stage: z.ZodOptional<z.ZodString>;
|
|
5097
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5098
|
-
who: z.ZodOptional<z.ZodString>;
|
|
5099
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5100
|
-
}, z.core.$strip>>;
|
|
5101
|
-
items: z.ZodArray<z.ZodObject<{
|
|
5102
|
-
id: z.ZodString;
|
|
5103
|
-
label: z.ZodString;
|
|
5104
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5105
|
-
}, 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;
|
|
5106
5311
|
}, z.core.$strip>;
|
|
5107
|
-
export declare const
|
|
5108
|
-
|
|
5109
|
-
stage: z.ZodString;
|
|
5110
|
-
file: z.ZodString;
|
|
5111
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5112
|
-
label: z.ZodString;
|
|
5113
|
-
text: z.ZodString;
|
|
5114
|
-
scope: z.ZodEnum<{
|
|
5115
|
-
one: "one";
|
|
5116
|
-
similar: "similar";
|
|
5117
|
-
}>;
|
|
5118
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5119
|
-
by: z.ZodString;
|
|
5312
|
+
export declare const ThreadItem: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
5313
|
+
kind: z.ZodLiteral<"prompt">;
|
|
5120
5314
|
at: z.ZodString;
|
|
5315
|
+
runId: z.ZodString;
|
|
5316
|
+
who: z.ZodEnum<{
|
|
5317
|
+
critic: "critic";
|
|
5318
|
+
drafter: "drafter";
|
|
5319
|
+
}>;
|
|
5320
|
+
prompt: z.ZodString;
|
|
5121
5321
|
state: z.ZodEnum<{
|
|
5122
|
-
|
|
5123
|
-
|
|
5322
|
+
failed: "failed";
|
|
5323
|
+
prepared: "prepared";
|
|
5124
5324
|
waiting: "waiting";
|
|
5325
|
+
produced: "produced";
|
|
5326
|
+
validated: "validated";
|
|
5327
|
+
cancelled: "cancelled";
|
|
5125
5328
|
}>;
|
|
5126
|
-
|
|
5127
|
-
|
|
5128
|
-
|
|
5129
|
-
|
|
5130
|
-
|
|
5131
|
-
|
|
5132
|
-
|
|
5133
|
-
|
|
5134
|
-
|
|
5135
|
-
|
|
5136
|
-
|
|
5137
|
-
|
|
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";
|
|
5138
5345
|
}>;
|
|
5139
|
-
|
|
5140
|
-
|
|
5141
|
-
|
|
5142
|
-
|
|
5143
|
-
|
|
5144
|
-
|
|
5145
|
-
|
|
5146
|
-
|
|
5147
|
-
|
|
5148
|
-
|
|
5149
|
-
|
|
5150
|
-
|
|
5151
|
-
|
|
5152
|
-
|
|
5153
|
-
|
|
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>;
|
|
5154
5367
|
id: z.ZodString;
|
|
5155
|
-
label: z.ZodString;
|
|
5156
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5157
|
-
}, z.core.$strip>>;
|
|
5158
|
-
}, z.core.$strip>>;
|
|
5159
|
-
corrections: z.ZodArray<z.ZodObject<{
|
|
5160
|
-
id: z.ZodString;
|
|
5161
|
-
stage: z.ZodString;
|
|
5162
|
-
file: z.ZodString;
|
|
5163
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5164
|
-
label: z.ZodString;
|
|
5165
|
-
text: z.ZodString;
|
|
5166
|
-
scope: z.ZodEnum<{
|
|
5167
|
-
one: "one";
|
|
5168
|
-
similar: "similar";
|
|
5169
|
-
}>;
|
|
5170
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5171
|
-
by: z.ZodString;
|
|
5172
|
-
at: z.ZodString;
|
|
5173
|
-
state: z.ZodEnum<{
|
|
5174
|
-
read: "read";
|
|
5175
|
-
applied: "applied";
|
|
5176
|
-
waiting: "waiting";
|
|
5177
|
-
}>;
|
|
5178
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5179
|
-
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5180
|
-
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5181
|
-
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5182
|
-
}, z.core.$strip>>;
|
|
5183
|
-
next: z.ZodObject<{
|
|
5184
|
-
stage: z.ZodString;
|
|
5185
|
-
command: z.ZodString;
|
|
5186
|
-
slash: z.ZodString;
|
|
5187
|
-
}, z.core.$strip>;
|
|
5188
|
-
problems: z.ZodArray<z.ZodObject<{
|
|
5189
|
-
file: z.ZodString;
|
|
5190
|
-
message: z.ZodString;
|
|
5191
|
-
}, z.core.$strip>>;
|
|
5192
|
-
}, z.core.$strip>;
|
|
5193
|
-
export declare const AddCorrectionRequest: z.ZodObject<{
|
|
5194
|
-
file: z.ZodString;
|
|
5195
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5196
|
-
text: z.ZodString;
|
|
5197
|
-
similar: z.ZodDefault<z.ZodBoolean>;
|
|
5198
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5199
|
-
}, z.core.$strict>;
|
|
5200
|
-
export declare const CorrectionResult: z.ZodObject<{
|
|
5201
|
-
correction: z.ZodObject<{
|
|
5202
|
-
id: z.ZodString;
|
|
5203
|
-
stage: z.ZodString;
|
|
5204
|
-
file: z.ZodString;
|
|
5205
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5206
|
-
label: z.ZodString;
|
|
5207
|
-
text: z.ZodString;
|
|
5208
|
-
scope: z.ZodEnum<{
|
|
5209
|
-
one: "one";
|
|
5210
|
-
similar: "similar";
|
|
5211
|
-
}>;
|
|
5212
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5213
|
-
by: z.ZodString;
|
|
5214
|
-
at: z.ZodString;
|
|
5215
|
-
state: z.ZodEnum<{
|
|
5216
|
-
read: "read";
|
|
5217
|
-
applied: "applied";
|
|
5218
|
-
waiting: "waiting";
|
|
5219
|
-
}>;
|
|
5220
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5221
|
-
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5222
|
-
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5223
|
-
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5224
|
-
}, z.core.$strip>;
|
|
5225
|
-
files: z.ZodArray<z.ZodString>;
|
|
5226
|
-
commit: z.ZodString;
|
|
5227
|
-
next: z.ZodObject<{
|
|
5228
|
-
stage: z.ZodString;
|
|
5229
|
-
command: z.ZodString;
|
|
5230
|
-
slash: z.ZodString;
|
|
5231
|
-
}, z.core.$strip>;
|
|
5232
|
-
}, z.core.$strip>;
|
|
5233
|
-
export declare const CorrectionList: z.ZodObject<{
|
|
5234
|
-
change: z.ZodString;
|
|
5235
|
-
corrections: z.ZodArray<z.ZodObject<{
|
|
5236
|
-
id: z.ZodString;
|
|
5237
|
-
stage: z.ZodString;
|
|
5238
|
-
file: z.ZodString;
|
|
5239
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5240
|
-
label: z.ZodString;
|
|
5241
|
-
text: z.ZodString;
|
|
5242
|
-
scope: z.ZodEnum<{
|
|
5243
|
-
one: "one";
|
|
5244
|
-
similar: "similar";
|
|
5245
|
-
}>;
|
|
5246
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5247
|
-
by: z.ZodString;
|
|
5248
|
-
at: z.ZodString;
|
|
5249
|
-
state: z.ZodEnum<{
|
|
5250
|
-
read: "read";
|
|
5251
|
-
applied: "applied";
|
|
5252
|
-
waiting: "waiting";
|
|
5253
|
-
}>;
|
|
5254
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5255
|
-
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5256
|
-
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5257
|
-
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5258
|
-
}, z.core.$strip>>;
|
|
5259
|
-
}, z.core.$strip>;
|
|
5260
|
-
export type StageDraftsViewT = z.infer<typeof StageDraftsView>;
|
|
5261
|
-
export type DraftFileViewT = z.infer<typeof DraftFileView>;
|
|
5262
|
-
export type DraftProvenanceT = z.infer<typeof DraftProvenance>;
|
|
5263
|
-
export type CorrectionViewT = z.infer<typeof CorrectionView>;
|
|
5264
|
-
export type CorrectionResultT = z.infer<typeof CorrectionResult>;
|
|
5265
|
-
export type CorrectionListT = z.infer<typeof CorrectionList>;
|
|
5266
|
-
/**
|
|
5267
|
-
* ADR 0092: the specs (ADR 0079) as the Flows screen reads them, from files only: the repos
|
|
5268
|
-
* with a spec, one repo's flows, and one flow with the joins of the estate pass (ADR 0085).
|
|
5269
|
-
*/
|
|
5270
|
-
export declare const SpecList: z.ZodObject<{
|
|
5271
|
-
repos: z.ZodArray<z.ZodObject<{
|
|
5272
|
-
repo: z.ZodString;
|
|
5273
|
-
flows: z.ZodNumber;
|
|
5274
|
-
}, z.core.$strip>>;
|
|
5275
|
-
}, z.core.$strip>;
|
|
5276
|
-
export declare const SpecFlowSummary: z.ZodObject<{
|
|
5277
|
-
id: z.ZodString;
|
|
5278
|
-
name: z.ZodString;
|
|
5279
|
-
component: z.ZodString;
|
|
5280
|
-
trigger: z.ZodObject<{
|
|
5281
|
-
kind: z.ZodString;
|
|
5282
|
-
what: z.ZodString;
|
|
5283
|
-
}, z.core.$strip>;
|
|
5284
|
-
steps: z.ZodNumber;
|
|
5285
|
-
confirmed: z.ZodNumber;
|
|
5286
|
-
errors: z.ZodNumber;
|
|
5287
|
-
calls: z.ZodNumber;
|
|
5288
|
-
calledBy: z.ZodNumber;
|
|
5289
|
-
}, z.core.$strip>;
|
|
5290
|
-
export declare const SpecView: z.ZodObject<{
|
|
5291
|
-
repo: z.ZodString;
|
|
5292
|
-
path: z.ZodString;
|
|
5293
|
-
commit: z.ZodOptional<z.ZodString>;
|
|
5294
|
-
template: z.ZodOptional<z.ZodString>;
|
|
5295
|
-
flows: z.ZodArray<z.ZodObject<{
|
|
5296
|
-
id: z.ZodString;
|
|
5297
|
-
name: z.ZodString;
|
|
5298
|
-
component: z.ZodString;
|
|
5299
|
-
trigger: z.ZodObject<{
|
|
5300
|
-
kind: z.ZodString;
|
|
5301
|
-
what: z.ZodString;
|
|
5302
|
-
}, z.core.$strip>;
|
|
5303
|
-
steps: z.ZodNumber;
|
|
5304
|
-
confirmed: z.ZodNumber;
|
|
5305
|
-
errors: z.ZodNumber;
|
|
5306
|
-
calls: z.ZodNumber;
|
|
5307
|
-
calledBy: z.ZodNumber;
|
|
5308
|
-
}, z.core.$strip>>;
|
|
5309
|
-
problems: z.ZodArray<z.ZodObject<{
|
|
5310
|
-
file: z.ZodString;
|
|
5311
|
-
message: z.ZodString;
|
|
5312
|
-
}, z.core.$strip>>;
|
|
5313
|
-
}, z.core.$strip>;
|
|
5314
|
-
/** A step of one flow joined to a step or trigger of another (estate.yaml). */
|
|
5315
|
-
export declare const FlowLink: z.ZodObject<{
|
|
5316
|
-
step: z.ZodNumber;
|
|
5317
|
-
repo: z.ZodString;
|
|
5318
|
-
flow: z.ZodString;
|
|
5319
|
-
name: z.ZodOptional<z.ZodString>;
|
|
5320
|
-
how: z.ZodString;
|
|
5321
|
-
}, z.core.$strip>;
|
|
5322
|
-
export declare const FlowView: z.ZodObject<{
|
|
5323
|
-
repo: z.ZodString;
|
|
5324
|
-
file: z.ZodString;
|
|
5325
|
-
flow: z.ZodObject<{
|
|
5326
|
-
kind: z.ZodLiteral<"Flow">;
|
|
5327
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
5328
|
-
id: z.ZodString;
|
|
5329
|
-
status: z.ZodDefault<z.ZodEnum<{
|
|
5330
|
-
current: "current";
|
|
5331
|
-
"planned-new": "planned-new";
|
|
5332
|
-
"planned-modify": "planned-modify";
|
|
5333
|
-
"planned-retire": "planned-retire";
|
|
5334
|
-
retired: "retired";
|
|
5335
|
-
}>>;
|
|
5336
|
-
confidence: z.ZodDefault<z.ZodEnum<{
|
|
5337
|
-
verified: "verified";
|
|
5338
|
-
inferred: "inferred";
|
|
5339
|
-
asserted: "asserted";
|
|
5340
|
-
}>>;
|
|
5341
|
-
evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
5342
|
-
source: z.ZodEnum<{
|
|
5343
|
-
code: "code";
|
|
5344
|
-
config: "config";
|
|
5345
|
-
spec: "spec";
|
|
5346
|
-
gateway: "gateway";
|
|
5347
|
-
"event-config": "event-config";
|
|
5348
|
-
infrastructure: "infrastructure";
|
|
5349
|
-
pipeline: "pipeline";
|
|
5350
|
-
migration: "migration";
|
|
5351
|
-
diagram: "diagram";
|
|
5352
|
-
document: "document";
|
|
5353
|
-
export: "export";
|
|
5354
|
-
manual: "manual";
|
|
5355
|
-
ai: "ai";
|
|
5356
|
-
}>;
|
|
5357
|
-
repo: z.ZodOptional<z.ZodString>;
|
|
5358
|
-
path: z.ZodOptional<z.ZodString>;
|
|
5359
|
-
line: z.ZodOptional<z.ZodNumber>;
|
|
5360
|
-
commit: z.ZodOptional<z.ZodString>;
|
|
5361
|
-
scannedAt: z.ZodOptional<z.ZodISODateTime>;
|
|
5362
|
-
extractor: z.ZodOptional<z.ZodString>;
|
|
5363
|
-
dialect: z.ZodOptional<z.ZodString>;
|
|
5364
|
-
side: z.ZodOptional<z.ZodEnum<{
|
|
5365
|
-
gateway: "gateway";
|
|
5366
|
-
document: "document";
|
|
5367
|
-
caller: "caller";
|
|
5368
|
-
callee: "callee";
|
|
5369
|
-
definition: "definition";
|
|
5370
|
-
}>>;
|
|
5371
|
-
by: z.ZodOptional<z.ZodString>;
|
|
5372
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5373
|
-
}, z.core.$strict>>>;
|
|
5374
|
-
flags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5375
|
-
component: z.ZodString;
|
|
5376
|
-
name: z.ZodString;
|
|
5377
|
-
trigger: z.ZodObject<{
|
|
5378
5368
|
kind: z.ZodEnum<{
|
|
5379
|
-
|
|
5380
|
-
|
|
5381
|
-
action: "action";
|
|
5382
|
-
listener: "listener";
|
|
5383
|
-
job: "job";
|
|
5369
|
+
issue: "issue";
|
|
5370
|
+
"knowledge-gap": "knowledge-gap";
|
|
5384
5371
|
}>;
|
|
5385
|
-
|
|
5386
|
-
|
|
5387
|
-
|
|
5388
|
-
|
|
5389
|
-
|
|
5390
|
-
|
|
5391
|
-
|
|
5392
|
-
|
|
5393
|
-
|
|
5394
|
-
|
|
5395
|
-
|
|
5396
|
-
|
|
5397
|
-
|
|
5398
|
-
|
|
5399
|
-
|
|
5400
|
-
|
|
5401
|
-
|
|
5402
|
-
|
|
5403
|
-
|
|
5404
|
-
|
|
5405
|
-
|
|
5406
|
-
|
|
5407
|
-
|
|
5408
|
-
|
|
5409
|
-
|
|
5410
|
-
|
|
5411
|
-
|
|
5412
|
-
|
|
5413
|
-
|
|
5414
|
-
|
|
5415
|
-
|
|
5416
|
-
|
|
5417
|
-
|
|
5418
|
-
|
|
5419
|
-
|
|
5420
|
-
|
|
5421
|
-
|
|
5422
|
-
|
|
5423
|
-
|
|
5424
|
-
|
|
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>;
|
|
5425
5413
|
evidence: z.ZodArray<z.ZodObject<{
|
|
5426
|
-
source: z.ZodEnum<{
|
|
5414
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
5427
5415
|
code: "code";
|
|
5428
5416
|
config: "config";
|
|
5429
5417
|
spec: "spec";
|
|
@@ -5436,7 +5424,1524 @@ export declare const FlowView: z.ZodObject<{
|
|
|
5436
5424
|
document: "document";
|
|
5437
5425
|
export: "export";
|
|
5438
5426
|
manual: "manual";
|
|
5439
|
-
|
|
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>;
|
|
6718
|
+
by: z.ZodString;
|
|
6719
|
+
at: z.ZodString;
|
|
6720
|
+
state: z.ZodEnum<{
|
|
6721
|
+
read: "read";
|
|
6722
|
+
applied: "applied";
|
|
6723
|
+
waiting: "waiting";
|
|
6724
|
+
}>;
|
|
6725
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6726
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
6727
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
6728
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6729
|
+
}, z.core.$strip>;
|
|
6730
|
+
files: z.ZodArray<z.ZodString>;
|
|
6731
|
+
commit: z.ZodString;
|
|
6732
|
+
next: z.ZodObject<{
|
|
6733
|
+
stage: z.ZodString;
|
|
6734
|
+
command: z.ZodString;
|
|
6735
|
+
slash: z.ZodString;
|
|
6736
|
+
}, z.core.$strip>;
|
|
6737
|
+
}, z.core.$strip>;
|
|
6738
|
+
export declare const CorrectionList: z.ZodObject<{
|
|
6739
|
+
change: z.ZodString;
|
|
6740
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
6741
|
+
id: z.ZodString;
|
|
6742
|
+
stage: z.ZodString;
|
|
6743
|
+
file: z.ZodString;
|
|
6744
|
+
item: z.ZodOptional<z.ZodString>;
|
|
6745
|
+
label: z.ZodString;
|
|
6746
|
+
text: z.ZodString;
|
|
6747
|
+
scope: z.ZodEnum<{
|
|
6748
|
+
one: "one";
|
|
6749
|
+
similar: "similar";
|
|
6750
|
+
}>;
|
|
6751
|
+
like: z.ZodOptional<z.ZodString>;
|
|
6752
|
+
by: z.ZodString;
|
|
6753
|
+
at: z.ZodString;
|
|
6754
|
+
state: z.ZodEnum<{
|
|
6755
|
+
read: "read";
|
|
6756
|
+
applied: "applied";
|
|
6757
|
+
waiting: "waiting";
|
|
6758
|
+
}>;
|
|
6759
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6760
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
6761
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
6762
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6763
|
+
}, z.core.$strip>>;
|
|
6764
|
+
}, z.core.$strip>;
|
|
6765
|
+
export type StageDraftsViewT = z.infer<typeof StageDraftsView>;
|
|
6766
|
+
export type DraftFileViewT = z.infer<typeof DraftFileView>;
|
|
6767
|
+
export type DraftProvenanceT = z.infer<typeof DraftProvenance>;
|
|
6768
|
+
export type CorrectionViewT = z.infer<typeof CorrectionView>;
|
|
6769
|
+
export type CorrectionResultT = z.infer<typeof CorrectionResult>;
|
|
6770
|
+
export type CorrectionListT = z.infer<typeof CorrectionList>;
|
|
6771
|
+
/**
|
|
6772
|
+
* ADR 0092: the specs (ADR 0079) as the Flows screen reads them, from files only: the repos
|
|
6773
|
+
* with a spec, one repo's flows, and one flow with the joins of the estate pass (ADR 0085).
|
|
6774
|
+
*/
|
|
6775
|
+
export declare const SpecList: z.ZodObject<{
|
|
6776
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
6777
|
+
repo: z.ZodString;
|
|
6778
|
+
flows: z.ZodNumber;
|
|
6779
|
+
}, z.core.$strip>>;
|
|
6780
|
+
}, z.core.$strip>;
|
|
6781
|
+
export declare const SpecFlowSummary: z.ZodObject<{
|
|
6782
|
+
id: z.ZodString;
|
|
6783
|
+
name: z.ZodString;
|
|
6784
|
+
component: z.ZodString;
|
|
6785
|
+
trigger: z.ZodObject<{
|
|
6786
|
+
kind: z.ZodString;
|
|
6787
|
+
what: z.ZodString;
|
|
6788
|
+
}, z.core.$strip>;
|
|
6789
|
+
steps: z.ZodNumber;
|
|
6790
|
+
confirmed: z.ZodNumber;
|
|
6791
|
+
errors: z.ZodNumber;
|
|
6792
|
+
calls: z.ZodNumber;
|
|
6793
|
+
calledBy: z.ZodNumber;
|
|
6794
|
+
}, z.core.$strip>;
|
|
6795
|
+
export declare const SpecView: z.ZodObject<{
|
|
6796
|
+
repo: z.ZodString;
|
|
6797
|
+
path: z.ZodString;
|
|
6798
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
6799
|
+
template: z.ZodOptional<z.ZodString>;
|
|
6800
|
+
flows: z.ZodArray<z.ZodObject<{
|
|
6801
|
+
id: z.ZodString;
|
|
6802
|
+
name: z.ZodString;
|
|
6803
|
+
component: z.ZodString;
|
|
6804
|
+
trigger: z.ZodObject<{
|
|
6805
|
+
kind: z.ZodString;
|
|
6806
|
+
what: z.ZodString;
|
|
6807
|
+
}, z.core.$strip>;
|
|
6808
|
+
steps: z.ZodNumber;
|
|
6809
|
+
confirmed: z.ZodNumber;
|
|
6810
|
+
errors: z.ZodNumber;
|
|
6811
|
+
calls: z.ZodNumber;
|
|
6812
|
+
calledBy: z.ZodNumber;
|
|
6813
|
+
}, z.core.$strip>>;
|
|
6814
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6815
|
+
file: z.ZodString;
|
|
6816
|
+
message: z.ZodString;
|
|
6817
|
+
}, z.core.$strip>>;
|
|
6818
|
+
}, z.core.$strip>;
|
|
6819
|
+
/** A step of one flow joined to a step or trigger of another (estate.yaml). */
|
|
6820
|
+
export declare const FlowLink: z.ZodObject<{
|
|
6821
|
+
step: z.ZodNumber;
|
|
6822
|
+
repo: z.ZodString;
|
|
6823
|
+
flow: z.ZodString;
|
|
6824
|
+
name: z.ZodOptional<z.ZodString>;
|
|
6825
|
+
how: z.ZodString;
|
|
6826
|
+
}, z.core.$strip>;
|
|
6827
|
+
export declare const FlowView: z.ZodObject<{
|
|
6828
|
+
repo: z.ZodString;
|
|
6829
|
+
file: z.ZodString;
|
|
6830
|
+
flow: z.ZodObject<{
|
|
6831
|
+
kind: z.ZodLiteral<"Flow">;
|
|
6832
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
6833
|
+
id: z.ZodString;
|
|
6834
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
6835
|
+
current: "current";
|
|
6836
|
+
"planned-new": "planned-new";
|
|
6837
|
+
"planned-modify": "planned-modify";
|
|
6838
|
+
"planned-retire": "planned-retire";
|
|
6839
|
+
retired: "retired";
|
|
6840
|
+
}>>;
|
|
6841
|
+
confidence: z.ZodDefault<z.ZodEnum<{
|
|
6842
|
+
verified: "verified";
|
|
6843
|
+
inferred: "inferred";
|
|
6844
|
+
asserted: "asserted";
|
|
6845
|
+
}>>;
|
|
6846
|
+
evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
6847
|
+
source: z.ZodEnum<{
|
|
6848
|
+
code: "code";
|
|
6849
|
+
config: "config";
|
|
6850
|
+
spec: "spec";
|
|
6851
|
+
gateway: "gateway";
|
|
6852
|
+
"event-config": "event-config";
|
|
6853
|
+
infrastructure: "infrastructure";
|
|
6854
|
+
pipeline: "pipeline";
|
|
6855
|
+
migration: "migration";
|
|
6856
|
+
diagram: "diagram";
|
|
6857
|
+
document: "document";
|
|
6858
|
+
export: "export";
|
|
6859
|
+
manual: "manual";
|
|
6860
|
+
ai: "ai";
|
|
6861
|
+
}>;
|
|
6862
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6863
|
+
path: z.ZodOptional<z.ZodString>;
|
|
6864
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6865
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
6866
|
+
scannedAt: z.ZodOptional<z.ZodISODateTime>;
|
|
6867
|
+
extractor: z.ZodOptional<z.ZodString>;
|
|
6868
|
+
dialect: z.ZodOptional<z.ZodString>;
|
|
6869
|
+
side: z.ZodOptional<z.ZodEnum<{
|
|
6870
|
+
gateway: "gateway";
|
|
6871
|
+
document: "document";
|
|
6872
|
+
caller: "caller";
|
|
6873
|
+
callee: "callee";
|
|
6874
|
+
definition: "definition";
|
|
6875
|
+
}>>;
|
|
6876
|
+
by: z.ZodOptional<z.ZodString>;
|
|
6877
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6878
|
+
}, z.core.$strict>>>;
|
|
6879
|
+
flags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6880
|
+
component: z.ZodString;
|
|
6881
|
+
name: z.ZodString;
|
|
6882
|
+
trigger: z.ZodObject<{
|
|
6883
|
+
kind: z.ZodEnum<{
|
|
6884
|
+
endpoint: "endpoint";
|
|
6885
|
+
page: "page";
|
|
6886
|
+
action: "action";
|
|
6887
|
+
listener: "listener";
|
|
6888
|
+
job: "job";
|
|
6889
|
+
}>;
|
|
6890
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
6891
|
+
what: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodTransform<string, string | number | boolean>>, z.ZodString>;
|
|
6892
|
+
caller: z.ZodOptional<z.ZodObject<{
|
|
6893
|
+
who: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodTransform<string, string | number | boolean>>, z.ZodString>;
|
|
6894
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
6895
|
+
via: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodTransform<string, string | number | boolean>>, z.ZodString>>;
|
|
6896
|
+
evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
6897
|
+
source: z.ZodEnum<{
|
|
6898
|
+
code: "code";
|
|
6899
|
+
config: "config";
|
|
6900
|
+
spec: "spec";
|
|
6901
|
+
gateway: "gateway";
|
|
6902
|
+
"event-config": "event-config";
|
|
6903
|
+
infrastructure: "infrastructure";
|
|
6904
|
+
pipeline: "pipeline";
|
|
6905
|
+
migration: "migration";
|
|
6906
|
+
diagram: "diagram";
|
|
6907
|
+
document: "document";
|
|
6908
|
+
export: "export";
|
|
6909
|
+
manual: "manual";
|
|
6910
|
+
ai: "ai";
|
|
6911
|
+
}>;
|
|
6912
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6913
|
+
path: z.ZodOptional<z.ZodString>;
|
|
6914
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6915
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
6916
|
+
scannedAt: z.ZodOptional<z.ZodISODateTime>;
|
|
6917
|
+
extractor: z.ZodOptional<z.ZodString>;
|
|
6918
|
+
dialect: z.ZodOptional<z.ZodString>;
|
|
6919
|
+
side: z.ZodOptional<z.ZodEnum<{
|
|
6920
|
+
gateway: "gateway";
|
|
6921
|
+
document: "document";
|
|
6922
|
+
caller: "caller";
|
|
6923
|
+
callee: "callee";
|
|
6924
|
+
definition: "definition";
|
|
6925
|
+
}>>;
|
|
6926
|
+
by: z.ZodOptional<z.ZodString>;
|
|
6927
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6928
|
+
}, z.core.$strict>>>;
|
|
6929
|
+
}, z.core.$strict>>;
|
|
6930
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
6931
|
+
source: z.ZodEnum<{
|
|
6932
|
+
code: "code";
|
|
6933
|
+
config: "config";
|
|
6934
|
+
spec: "spec";
|
|
6935
|
+
gateway: "gateway";
|
|
6936
|
+
"event-config": "event-config";
|
|
6937
|
+
infrastructure: "infrastructure";
|
|
6938
|
+
pipeline: "pipeline";
|
|
6939
|
+
migration: "migration";
|
|
6940
|
+
diagram: "diagram";
|
|
6941
|
+
document: "document";
|
|
6942
|
+
export: "export";
|
|
6943
|
+
manual: "manual";
|
|
6944
|
+
ai: "ai";
|
|
5440
6945
|
}>;
|
|
5441
6946
|
repo: z.ZodOptional<z.ZodString>;
|
|
5442
6947
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -6345,11 +7850,13 @@ export declare const Health: z.ZodObject<{
|
|
|
6345
7850
|
openspec: z.ZodOptional<z.ZodString>;
|
|
6346
7851
|
user: z.ZodString;
|
|
6347
7852
|
full: z.ZodOptional<z.ZodBoolean>;
|
|
7853
|
+
metarepo: z.ZodOptional<z.ZodBoolean>;
|
|
6348
7854
|
}, z.core.$strip>;
|
|
6349
7855
|
export declare const ScanRequest: z.ZodObject<{
|
|
6350
7856
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6351
7857
|
full: z.ZodDefault<z.ZodBoolean>;
|
|
6352
7858
|
ref: z.ZodOptional<z.ZodString>;
|
|
7859
|
+
askAll: z.ZodOptional<z.ZodBoolean>;
|
|
6353
7860
|
}, z.core.$strict>;
|
|
6354
7861
|
/** ADR 0123: each repo's branches, as the Repos screen shows them. */
|
|
6355
7862
|
export declare const RepoBranchesView: z.ZodObject<{
|
|
@@ -6511,6 +8018,15 @@ export declare const ChangeCockpit: z.ZodObject<{
|
|
|
6511
8018
|
delivery: "delivery";
|
|
6512
8019
|
analysis: "analysis";
|
|
6513
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>>>;
|
|
6514
8030
|
repos: z.ZodArray<z.ZodObject<{
|
|
6515
8031
|
id: z.ZodString;
|
|
6516
8032
|
branch: z.ZodString;
|
|
@@ -6536,10 +8052,10 @@ export declare const NewChangeRequest: z.ZodObject<{
|
|
|
6536
8052
|
export declare const ProposeScope: z.ZodEnum<{
|
|
6537
8053
|
"service-desk": "service-desk";
|
|
6538
8054
|
"org-pack": "org-pack";
|
|
8055
|
+
work: "work";
|
|
6539
8056
|
audit: "audit";
|
|
6540
8057
|
corrections: "corrections";
|
|
6541
8058
|
answers: "answers";
|
|
6542
|
-
work: "work";
|
|
6543
8059
|
"owner-answers": "owner-answers";
|
|
6544
8060
|
baseline: "baseline";
|
|
6545
8061
|
initiatives: "initiatives";
|
|
@@ -6549,10 +8065,10 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6549
8065
|
scope: z.ZodEnum<{
|
|
6550
8066
|
"service-desk": "service-desk";
|
|
6551
8067
|
"org-pack": "org-pack";
|
|
8068
|
+
work: "work";
|
|
6552
8069
|
audit: "audit";
|
|
6553
8070
|
corrections: "corrections";
|
|
6554
8071
|
answers: "answers";
|
|
6555
|
-
work: "work";
|
|
6556
8072
|
"owner-answers": "owner-answers";
|
|
6557
8073
|
baseline: "baseline";
|
|
6558
8074
|
initiatives: "initiatives";
|
|
@@ -6568,14 +8084,79 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6568
8084
|
title: z.ZodString;
|
|
6569
8085
|
applyFirst: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6570
8086
|
}, z.core.$strip>;
|
|
8087
|
+
/**
|
|
8088
|
+
* 3.0.0 (ADR 0186, review round 48): the writes to shared systems a person confirms in the app.
|
|
8089
|
+
* The session token drives the API and is printed for assistants and scripts (`--show-token`),
|
|
8090
|
+
* so it isn't a person's yes: the app's page asks for a confirmation (POST /api/confirmations,
|
|
8091
|
+
* with the page key only the page is given) when the person clicks, and the write sends it once.
|
|
8092
|
+
* `merge` is Sync's merge of a ready PR; `ai-model` a change of where runtime.yaml sends the
|
|
8093
|
+
* model's key (its provider, keyEnv or an address); `ai-test` a Test of settings not committed.
|
|
8094
|
+
*/
|
|
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"];
|
|
8096
|
+
export declare const ConfirmedWrite: z.ZodEnum<{
|
|
8097
|
+
propose: "propose";
|
|
8098
|
+
handoff: "handoff";
|
|
8099
|
+
"release-prs": "release-prs";
|
|
8100
|
+
merge: "merge";
|
|
8101
|
+
"task-pr": "task-pr";
|
|
8102
|
+
"digest-send": "digest-send";
|
|
8103
|
+
"step-run": "step-run";
|
|
8104
|
+
"ai-model": "ai-model";
|
|
8105
|
+
"ai-test": "ai-test";
|
|
8106
|
+
"work-items": "work-items";
|
|
8107
|
+
"owner-ask": "owner-ask";
|
|
8108
|
+
}>;
|
|
8109
|
+
/** A confirmation the server gave the page: single use, for one write and target, two minutes. */
|
|
8110
|
+
export declare const Confirmation: z.ZodString;
|
|
8111
|
+
export declare const ConfirmationRequest: z.ZodObject<{
|
|
8112
|
+
write: z.ZodEnum<{
|
|
8113
|
+
propose: "propose";
|
|
8114
|
+
handoff: "handoff";
|
|
8115
|
+
"release-prs": "release-prs";
|
|
8116
|
+
merge: "merge";
|
|
8117
|
+
"task-pr": "task-pr";
|
|
8118
|
+
"digest-send": "digest-send";
|
|
8119
|
+
"step-run": "step-run";
|
|
8120
|
+
"ai-model": "ai-model";
|
|
8121
|
+
"ai-test": "ai-test";
|
|
8122
|
+
"work-items": "work-items";
|
|
8123
|
+
"owner-ask": "owner-ask";
|
|
8124
|
+
}>;
|
|
8125
|
+
target: z.ZodString;
|
|
8126
|
+
pageKey: z.ZodOptional<z.ZodString>;
|
|
8127
|
+
}, z.core.$strict>;
|
|
8128
|
+
export declare const ConfirmationView: z.ZodObject<{
|
|
8129
|
+
confirmation: z.ZodString;
|
|
8130
|
+
write: z.ZodEnum<{
|
|
8131
|
+
propose: "propose";
|
|
8132
|
+
handoff: "handoff";
|
|
8133
|
+
"release-prs": "release-prs";
|
|
8134
|
+
merge: "merge";
|
|
8135
|
+
"task-pr": "task-pr";
|
|
8136
|
+
"digest-send": "digest-send";
|
|
8137
|
+
"step-run": "step-run";
|
|
8138
|
+
"ai-model": "ai-model";
|
|
8139
|
+
"ai-test": "ai-test";
|
|
8140
|
+
"work-items": "work-items";
|
|
8141
|
+
"owner-ask": "owner-ask";
|
|
8142
|
+
}>;
|
|
8143
|
+
target: z.ZodString;
|
|
8144
|
+
expiresAt: z.ZodString;
|
|
8145
|
+
}, z.core.$strip>;
|
|
8146
|
+
/** The body of a write that takes nothing but the person's confirmation. */
|
|
8147
|
+
export declare const ConfirmedRequest: z.ZodObject<{
|
|
8148
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
8149
|
+
}, z.core.$strict>;
|
|
8150
|
+
export type ConfirmedWriteT = z.infer<typeof ConfirmedWrite>;
|
|
8151
|
+
export type ConfirmationViewT = z.infer<typeof ConfirmationView>;
|
|
6571
8152
|
export declare const ProposeRequest: z.ZodObject<{
|
|
6572
8153
|
scope: z.ZodEnum<{
|
|
6573
8154
|
"service-desk": "service-desk";
|
|
6574
8155
|
"org-pack": "org-pack";
|
|
8156
|
+
work: "work";
|
|
6575
8157
|
audit: "audit";
|
|
6576
8158
|
corrections: "corrections";
|
|
6577
8159
|
answers: "answers";
|
|
6578
|
-
work: "work";
|
|
6579
8160
|
"owner-answers": "owner-answers";
|
|
6580
8161
|
baseline: "baseline";
|
|
6581
8162
|
initiatives: "initiatives";
|
|
@@ -6584,6 +8165,7 @@ export declare const ProposeRequest: z.ZodObject<{
|
|
|
6584
8165
|
files: z.ZodArray<z.ZodString>;
|
|
6585
8166
|
title: z.ZodOptional<z.ZodString>;
|
|
6586
8167
|
branch: z.ZodOptional<z.ZodString>;
|
|
8168
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
6587
8169
|
}, z.core.$strict>;
|
|
6588
8170
|
export declare const LinesView: z.ZodObject<{
|
|
6589
8171
|
code: z.ZodOptional<z.ZodNumber>;
|
|
@@ -7607,16 +9189,36 @@ export declare const HandoffRequest: z.ZodObject<{
|
|
|
7607
9189
|
build: "build";
|
|
7608
9190
|
}>>;
|
|
7609
9191
|
repo: z.ZodOptional<z.ZodString>;
|
|
9192
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7610
9193
|
}, z.core.$strict>;
|
|
7611
|
-
/**
|
|
9194
|
+
/**
|
|
9195
|
+
* ADR 0043: refresh a change from its hand-off PR. 3.0.0 (ADR 0186): with a confirmation
|
|
9196
|
+
* (`merge`, the change) it merges a ready PR as the person; without one it only reads.
|
|
9197
|
+
*/
|
|
7612
9198
|
export declare const SyncRequest: z.ZodObject<{
|
|
7613
9199
|
repo: z.ZodOptional<z.ZodString>;
|
|
9200
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7614
9201
|
}, z.core.$strict>;
|
|
7615
9202
|
/** ADR 0184: raise the release PRs, change/<id> into each code repo's default branch. */
|
|
7616
|
-
export declare const ReleasePrsRequest: z.ZodObject<{
|
|
9203
|
+
export declare const ReleasePrsRequest: z.ZodObject<{
|
|
9204
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
9205
|
+
}, z.core.$strict>;
|
|
7617
9206
|
/** 2.75.0 (seventh UX walk): tick (done) or untick a task in the change's tasks.md. */
|
|
7618
9207
|
export declare const TaskDoneRequest: z.ZodObject<{
|
|
7619
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>;
|
|
7620
9222
|
}, z.core.$strict>;
|
|
7621
9223
|
/**
|
|
7622
9224
|
* 2.83.0 (ninth UX walk): name a change's owners per role from the change page (an empty list
|
|
@@ -7704,6 +9306,7 @@ export declare const StepRunRequest: z.ZodObject<{
|
|
|
7704
9306
|
inputsSha256: z.ZodString;
|
|
7705
9307
|
fillOnly: z.ZodOptional<z.ZodBoolean>;
|
|
7706
9308
|
change: z.ZodOptional<z.ZodString>;
|
|
9309
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7707
9310
|
}, z.core.$strict>;
|
|
7708
9311
|
export declare const ArchiveRequest: z.ZodObject<{
|
|
7709
9312
|
rescan: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -7769,8 +9372,13 @@ export declare const SaveNotifyRequest: z.ZodObject<{
|
|
|
7769
9372
|
channel: z.ZodOptional<z.ZodString>;
|
|
7770
9373
|
}, z.core.$strict>;
|
|
7771
9374
|
/** ADR 0048: show the digest, or send it through the notify adapter (the click is the approval). */
|
|
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
|
+
*/
|
|
7772
9379
|
export declare const SendDigestRequest: z.ZodObject<{
|
|
7773
9380
|
send: z.ZodDefault<z.ZodBoolean>;
|
|
9381
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7774
9382
|
}, z.core.$strict>;
|
|
7775
9383
|
/** ADR 0043: choose one of a triage item's numbered options; it writes a curated decision. */
|
|
7776
9384
|
export declare const TriageDecideRequest: z.ZodObject<{
|
|
@@ -7825,7 +9433,7 @@ export declare const InitiativeSavedView: z.ZodObject<{
|
|
|
7825
9433
|
/** ADR 0078: the questions in questions/, and the files that aren't valid questions. */
|
|
7826
9434
|
export declare const QuestionList: z.ZodObject<{
|
|
7827
9435
|
questions: z.ZodArray<z.ZodObject<{
|
|
7828
|
-
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>]>;
|
|
7829
9437
|
id: z.ZodString;
|
|
7830
9438
|
askedBy: z.ZodObject<{
|
|
7831
9439
|
step: z.ZodString;
|
|
@@ -7861,6 +9469,21 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
7861
9469
|
delivery: "delivery";
|
|
7862
9470
|
analysis: "analysis";
|
|
7863
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>>;
|
|
7864
9487
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
7865
9488
|
finding: z.ZodOptional<z.ZodObject<{
|
|
7866
9489
|
change: z.ZodString;
|
|
@@ -8021,6 +9644,11 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
8021
9644
|
delivery: "delivery";
|
|
8022
9645
|
analysis: "analysis";
|
|
8023
9646
|
}>>;
|
|
9647
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
9648
|
+
business: "business";
|
|
9649
|
+
delivery: "delivery";
|
|
9650
|
+
design: "design";
|
|
9651
|
+
}>>;
|
|
8024
9652
|
proposal: z.ZodOptional<z.ZodObject<{
|
|
8025
9653
|
answer: z.ZodObject<{
|
|
8026
9654
|
option: z.ZodOptional<z.ZodNumber>;
|
|
@@ -8079,7 +9707,7 @@ export declare const AnswerQuestionRequest: z.ZodObject<{
|
|
|
8079
9707
|
/** ADR 0078: the answered question, the command to run next and, for a repo type, its skill file. */
|
|
8080
9708
|
export declare const AnsweredQuestion: z.ZodObject<{
|
|
8081
9709
|
question: z.ZodObject<{
|
|
8082
|
-
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>]>;
|
|
8083
9711
|
id: z.ZodString;
|
|
8084
9712
|
askedBy: z.ZodObject<{
|
|
8085
9713
|
step: z.ZodString;
|
|
@@ -8115,6 +9743,21 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
8115
9743
|
delivery: "delivery";
|
|
8116
9744
|
analysis: "analysis";
|
|
8117
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>>;
|
|
8118
9761
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
8119
9762
|
finding: z.ZodOptional<z.ZodObject<{
|
|
8120
9763
|
change: z.ZodString;
|
|
@@ -10035,17 +11678,211 @@ export declare const QuestionsProposeView: z.ZodObject<{
|
|
|
10035
11678
|
prompt: z.ZodOptional<z.ZodString>;
|
|
10036
11679
|
done: z.ZodOptional<z.ZodString>;
|
|
10037
11680
|
}, z.core.$strip>;
|
|
10038
|
-
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
10039
|
-
export declare const UpgradeView: z.ZodObject<{
|
|
10040
|
-
atticus: z.ZodString;
|
|
10041
|
-
newer: z.ZodBoolean;
|
|
10042
|
-
stamp: z.ZodOptional<z.ZodString>;
|
|
10043
|
-
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<{
|
|
10044
11788
|
id: z.ZodString;
|
|
10045
|
-
|
|
10046
|
-
|
|
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>>;
|
|
10047
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;
|
|
10048
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>;
|
|
10049
11886
|
export declare const ConnectLinksRequest: z.ZodObject<{
|
|
10050
11887
|
from: z.ZodString;
|
|
10051
11888
|
to: z.ZodObject<{
|
|
@@ -10152,6 +11989,7 @@ export declare const SketchStrokeRequest: z.ZodObject<{
|
|
|
10152
11989
|
kind: z.ZodEnum<{
|
|
10153
11990
|
table: "table";
|
|
10154
11991
|
call: "call";
|
|
11992
|
+
retire: "retire";
|
|
10155
11993
|
topic: "topic";
|
|
10156
11994
|
remove: "remove";
|
|
10157
11995
|
retarget: "retarget";
|
|
@@ -10483,210 +12321,815 @@ export declare const StartCopilotRunRequest: z.ZodObject<{
|
|
|
10483
12321
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10484
12322
|
force: z.ZodOptional<z.ZodBoolean>;
|
|
10485
12323
|
}, z.core.$strip>;
|
|
10486
|
-
export declare const CopilotRunState: z.ZodEnum<{
|
|
10487
|
-
done: "done";
|
|
10488
|
-
failed: "failed";
|
|
10489
|
-
running: "running";
|
|
10490
|
-
stopped: "stopped";
|
|
10491
|
-
}>;
|
|
10492
|
-
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<{
|
|
10493
12595
|
id: z.ZodString;
|
|
10494
|
-
|
|
10495
|
-
|
|
12596
|
+
from: z.ZodNumber;
|
|
12597
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12598
|
+
total: z.ZodNumber;
|
|
10496
12599
|
state: z.ZodEnum<{
|
|
12600
|
+
done: "done";
|
|
10497
12601
|
failed: "failed";
|
|
10498
12602
|
running: "running";
|
|
12603
|
+
waiting: "waiting";
|
|
12604
|
+
cancelled: "cancelled";
|
|
10499
12605
|
ended: "ended";
|
|
10500
12606
|
}>;
|
|
10501
|
-
ended: z.ZodOptional<z.ZodString>;
|
|
10502
|
-
from: z.ZodNumber;
|
|
10503
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10504
12607
|
}, z.core.$strip>;
|
|
10505
|
-
export
|
|
10506
|
-
|
|
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">;
|
|
10507
12627
|
jobId: z.ZodString;
|
|
10508
|
-
kind: z.ZodEnum<{
|
|
10509
|
-
repos: "repos";
|
|
10510
|
-
stale: "stale";
|
|
10511
|
-
gaps: "gaps";
|
|
10512
|
-
all: "all";
|
|
10513
|
-
}>;
|
|
10514
|
-
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10515
|
-
force: z.ZodOptional<z.ZodBoolean>;
|
|
10516
12628
|
state: z.ZodEnum<{
|
|
10517
12629
|
done: "done";
|
|
10518
12630
|
failed: "failed";
|
|
10519
12631
|
running: "running";
|
|
10520
|
-
|
|
12632
|
+
cancelled: "cancelled";
|
|
12633
|
+
queued: "queued";
|
|
12634
|
+
}>;
|
|
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>;
|
|
12685
|
+
}, z.core.$strip>;
|
|
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<{
|
|
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";
|
|
10521
12931
|
}>;
|
|
10522
|
-
|
|
10523
|
-
|
|
10524
|
-
|
|
10525
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10526
|
-
progress: z.ZodObject<{
|
|
10527
|
-
repos: z.ZodNumber;
|
|
10528
|
-
repoIndex: z.ZodNumber;
|
|
10529
|
-
repo: z.ZodOptional<z.ZodString>;
|
|
10530
|
-
session: z.ZodOptional<z.ZodString>;
|
|
10531
|
-
sessions: z.ZodNumber;
|
|
10532
|
-
}, z.core.$strip>;
|
|
10533
|
-
totals: z.ZodObject<{
|
|
10534
|
-
kept: z.ZodNumber;
|
|
10535
|
-
rejected: z.ZodNumber;
|
|
10536
|
-
tokens: z.ZodNumber;
|
|
10537
|
-
}, z.core.$strip>;
|
|
10538
|
-
message: z.ZodOptional<z.ZodString>;
|
|
10539
|
-
tabs: z.ZodArray<z.ZodObject<{
|
|
10540
|
-
id: z.ZodString;
|
|
12932
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12933
|
+
key: z.ZodString;
|
|
12934
|
+
type: z.ZodString;
|
|
10541
12935
|
title: z.ZodString;
|
|
10542
|
-
|
|
10543
|
-
|
|
10544
|
-
|
|
10545
|
-
|
|
10546
|
-
|
|
12936
|
+
action: z.ZodEnum<{
|
|
12937
|
+
update: "update";
|
|
12938
|
+
create: "create";
|
|
12939
|
+
unchanged: "unchanged";
|
|
12940
|
+
orphaned: "orphaned";
|
|
10547
12941
|
}>;
|
|
10548
|
-
|
|
10549
|
-
|
|
10550
|
-
|
|
12942
|
+
id: z.ZodOptional<z.ZodString>;
|
|
12943
|
+
step: z.ZodOptional<z.ZodString>;
|
|
12944
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10551
12945
|
}, z.core.$strip>>;
|
|
12946
|
+
command: z.ZodString;
|
|
10552
12947
|
}, z.core.$strip>;
|
|
10553
|
-
export
|
|
10554
|
-
|
|
10555
|
-
|
|
10556
|
-
|
|
10557
|
-
|
|
10558
|
-
|
|
10559
|
-
|
|
10560
|
-
|
|
10561
|
-
|
|
10562
|
-
|
|
10563
|
-
|
|
10564
|
-
|
|
10565
|
-
state: z.ZodEnum<{
|
|
10566
|
-
done: "done";
|
|
10567
|
-
failed: "failed";
|
|
10568
|
-
running: "running";
|
|
10569
|
-
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";
|
|
10570
12960
|
}>;
|
|
10571
|
-
|
|
10572
|
-
|
|
10573
|
-
|
|
10574
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10575
|
-
progress: z.ZodObject<{
|
|
10576
|
-
repos: z.ZodNumber;
|
|
10577
|
-
repoIndex: z.ZodNumber;
|
|
10578
|
-
repo: z.ZodOptional<z.ZodString>;
|
|
10579
|
-
session: z.ZodOptional<z.ZodString>;
|
|
10580
|
-
sessions: z.ZodNumber;
|
|
10581
|
-
}, z.core.$strip>;
|
|
10582
|
-
totals: z.ZodObject<{
|
|
10583
|
-
kept: z.ZodNumber;
|
|
10584
|
-
rejected: z.ZodNumber;
|
|
10585
|
-
tokens: z.ZodNumber;
|
|
10586
|
-
}, z.core.$strip>;
|
|
10587
|
-
message: z.ZodOptional<z.ZodString>;
|
|
10588
|
-
tabs: z.ZodArray<z.ZodObject<{
|
|
10589
|
-
id: z.ZodString;
|
|
12961
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12962
|
+
key: z.ZodString;
|
|
12963
|
+
type: z.ZodString;
|
|
10590
12964
|
title: z.ZodString;
|
|
10591
|
-
|
|
10592
|
-
|
|
10593
|
-
|
|
10594
|
-
|
|
10595
|
-
|
|
12965
|
+
action: z.ZodEnum<{
|
|
12966
|
+
update: "update";
|
|
12967
|
+
create: "create";
|
|
12968
|
+
unchanged: "unchanged";
|
|
12969
|
+
orphaned: "orphaned";
|
|
10596
12970
|
}>;
|
|
10597
|
-
|
|
10598
|
-
|
|
10599
|
-
|
|
12971
|
+
id: z.ZodOptional<z.ZodString>;
|
|
12972
|
+
step: z.ZodOptional<z.ZodString>;
|
|
12973
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10600
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;
|
|
10601
12982
|
}, z.core.$strip>>;
|
|
10602
|
-
|
|
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>;
|
|
10603
13005
|
why: z.ZodOptional<z.ZodString>;
|
|
10604
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10605
13006
|
}, z.core.$strip>;
|
|
10606
|
-
export type
|
|
10607
|
-
|
|
10608
|
-
export
|
|
10609
|
-
|
|
10610
|
-
|
|
10611
|
-
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
10612
|
-
/** Messages on the WebSocket at /api/events. */
|
|
10613
|
-
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
10614
|
-
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;
|
|
10615
13012
|
path: z.ZodString;
|
|
10616
|
-
|
|
10617
|
-
|
|
10618
|
-
|
|
10619
|
-
|
|
10620
|
-
|
|
10621
|
-
|
|
10622
|
-
|
|
10623
|
-
|
|
10624
|
-
|
|
10625
|
-
|
|
10626
|
-
|
|
10627
|
-
|
|
10628
|
-
|
|
10629
|
-
|
|
10630
|
-
|
|
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";
|
|
10631
13064
|
}>;
|
|
10632
|
-
|
|
10633
|
-
|
|
10634
|
-
|
|
10635
|
-
|
|
10636
|
-
|
|
10637
|
-
|
|
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;
|
|
10638
13094
|
state: z.ZodEnum<{
|
|
10639
|
-
|
|
10640
|
-
prepared: "prepared";
|
|
13095
|
+
applied: "applied";
|
|
10641
13096
|
waiting: "waiting";
|
|
10642
|
-
produced: "produced";
|
|
10643
|
-
validated: "validated";
|
|
10644
|
-
cancelled: "cancelled";
|
|
10645
13097
|
}>;
|
|
10646
|
-
|
|
10647
|
-
|
|
10648
|
-
|
|
10649
|
-
|
|
10650
|
-
|
|
10651
|
-
|
|
10652
|
-
|
|
10653
|
-
|
|
10654
|
-
|
|
10655
|
-
|
|
10656
|
-
|
|
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";
|
|
10657
13110
|
}>;
|
|
10658
|
-
|
|
10659
|
-
|
|
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;
|
|
10660
13123
|
state: z.ZodEnum<{
|
|
10661
|
-
|
|
10662
|
-
|
|
10663
|
-
running: "running";
|
|
10664
|
-
stopped: "stopped";
|
|
13124
|
+
applied: "applied";
|
|
13125
|
+
waiting: "waiting";
|
|
10665
13126
|
}>;
|
|
10666
|
-
|
|
10667
|
-
|
|
10668
|
-
|
|
10669
|
-
|
|
10670
|
-
|
|
10671
|
-
|
|
10672
|
-
|
|
10673
|
-
sessions: z.ZodNumber;
|
|
10674
|
-
}, z.core.$strip>;
|
|
10675
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10676
|
-
jobId: z.ZodString;
|
|
10677
|
-
totals: z.ZodObject<{
|
|
10678
|
-
kept: z.ZodNumber;
|
|
10679
|
-
rejected: z.ZodNumber;
|
|
10680
|
-
tokens: z.ZodNumber;
|
|
10681
|
-
}, z.core.$strip>;
|
|
10682
|
-
}, z.core.$strip>;
|
|
10683
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
10684
|
-
type: z.ZodLiteral<"copilot-run.lines">;
|
|
10685
|
-
runId: z.ZodString;
|
|
10686
|
-
tab: z.ZodString;
|
|
10687
|
-
title: z.ZodString;
|
|
10688
|
-
at: z.ZodNumber;
|
|
10689
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10690
|
-
}, 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>;
|
|
10691
13134
|
/** Build the OpenAPI 3.1 document from the zod schemas. */
|
|
10692
13135
|
export declare function openApiDocument(): Record<string, unknown>;
|