@heynixie/contract 0.74.0 → 0.76.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -152,6 +152,7 @@ var clientHeaderName = "x-nixie-client";
152
152
  var forgettableKinds = [
153
153
  "action.outcome",
154
154
  "action.queued",
155
+ "action.reconcile_checked",
155
156
  "action.retry_scheduled",
156
157
  "model.compaction_failed",
157
158
  "model.reply",
@@ -165,6 +166,8 @@ var forgettableKinds = [
165
166
  "proposals.deferred",
166
167
  "session.enrolled",
167
168
  "session.labelled",
169
+ "rules.mandate_proposed",
170
+ "rules.rule_proposed",
168
171
  "session_kept",
169
172
  "skills.write_rejected",
170
173
  "task.created",
@@ -468,6 +471,7 @@ var reviewReasonSchema = z8.enum([
468
471
  "from_photo",
469
472
  "sensitive",
470
473
  "subject_change",
474
+ "labels",
471
475
  "ask_rule"
472
476
  ]);
473
477
  var proposalSourceSchema = z8.object({
@@ -475,6 +479,12 @@ var proposalSourceSchema = z8.object({
475
479
  proposedAt: z8.date(),
476
480
  thread: z8.string().nullable()
477
481
  });
482
+ var proposalLabelsSchema = z8.object({
483
+ gist: z8.string(),
484
+ isLabelOnly: z8.boolean(),
485
+ topic: z8.string(),
486
+ triggers: z8.array(z8.string())
487
+ });
478
488
  var memoryProposalSchema = z8.object({
479
489
  actionHash: z8.string(),
480
490
  createdAt: z8.date(),
@@ -484,6 +494,7 @@ var memoryProposalSchema = z8.object({
484
494
  isSensitive: z8.boolean(),
485
495
  itemID: z8.string(),
486
496
  kind: kindSchema,
497
+ labels: proposalLabelsSchema.nullable(),
487
498
  lapseAt: z8.date(),
488
499
  newSubject: subjectSchema.nullable(),
489
500
  operation: z8.enum(["remember", "retire", "pin"]),
@@ -642,6 +653,7 @@ var bodySchema = z11.object({
642
653
  fields: z11.record(z11.string(), z11.string()),
643
654
  ruleSentence: z11.string().nullable(),
644
655
  approveLabel: z11.string(),
656
+ rule: z11.record(z11.string(), z11.unknown()).optional(),
645
657
  memory: memoryProposalSchema.optional()
646
658
  });
647
659
  var itemSchema = z11.object({
@@ -652,6 +664,35 @@ var itemSchema = z11.object({
652
664
  choices: z11.array(choiceSchema),
653
665
  passkeyChoices: z11.array(choiceSchema)
654
666
  });
667
+ var unknownReasonSchema = z11.enum([
668
+ "inconclusive",
669
+ "unknown_streak",
670
+ "no_reconcile",
671
+ "key_expired",
672
+ "not_found_ask"
673
+ ]);
674
+ var checkAnswerSchema = z11.enum(["found", "not_found", "inconclusive"]);
675
+ var attemptSchema = z11.object({ attempt: z11.int().nonnegative(), at: z11.date() });
676
+ var checkSchema = z11.object({ answer: checkAnswerSchema, at: z11.date() });
677
+ var unknownOutcomeSchema = z11.object({
678
+ actionID: z11.string(),
679
+ tool: z11.string(),
680
+ sentence: z11.string(),
681
+ fields: z11.record(z11.string(), z11.string()),
682
+ riskClass: z11.enum(["routine", "always_ask", "lifting"]),
683
+ reason: unknownReasonSchema,
684
+ becameUnknownAt: z11.date(),
685
+ attempts: z11.array(attemptSchema),
686
+ checks: z11.array(checkSchema)
687
+ });
688
+ var unknownChoiceSchema = z11.enum(["happened", "retry", "drop"]);
689
+ var unknownItemSchema = z11.object({
690
+ group: z11.literal("unknown_outcome"),
691
+ action: unknownOutcomeSchema,
692
+ task: taskSchema.nullable(),
693
+ choices: z11.array(unknownChoiceSchema),
694
+ passkeyChoices: z11.array(unknownChoiceSchema)
695
+ });
655
696
  var readItemSchema = z11.object({
656
697
  proposal: proposalSchema,
657
698
  body: bodySchema.nullable(),
@@ -730,7 +771,27 @@ var answerErrors = signedIn.errors(reusedIDErrors).errors({
730
771
  ...noPasskeyError,
731
772
  ...passkeyFailedError
732
773
  });
733
- var listedSchema = z11.object({ defer: deferSettingsSchema, items: z11.array(itemSchema) });
774
+ var listedSchema = z11.object({
775
+ defer: deferSettingsSchema,
776
+ items: z11.array(itemSchema),
777
+ unknownOutcomes: z11.array(unknownItemSchema)
778
+ });
779
+ var unknownAnswerSchema = z11.object({
780
+ actionID: z11.string().min(1).max(200),
781
+ choice: unknownChoiceSchema,
782
+ clientActionID: z11.uuid(),
783
+ passkey: authenticationResponseSchema.optional()
784
+ });
785
+ var unknownAnswerErrors = signedIn.errors(reusedIDErrors).errors({
786
+ NOT_ALLOWED: {
787
+ message: "The action waits for no answer about its outcome",
788
+ status: 403,
789
+ data: z11.object({ reason: z11.string() })
790
+ },
791
+ PASSKEY_REQUIRED: { message: "This answer needs a passkey check", status: 403 },
792
+ ...noPasskeyError,
793
+ ...passkeyFailedError
794
+ });
734
795
  var readInputSchema = z11.object({
735
796
  proposalIDs: z11.array(z11.string().min(1).max(200)).min(1).max(100)
736
797
  });
@@ -740,6 +801,7 @@ var approvalContract = {
740
801
  listItems: signedIn.output(listedSchema),
741
802
  readProposals: signedIn.input(readInputSchema).output(z11.object({ proposals: z11.array(readItemSchema) })),
742
803
  answerProposal: answerErrors.input(passkeyAnswerSchema).output(resultSchema),
804
+ answerUnknownOutcome: unknownAnswerErrors.input(unknownAnswerSchema).output(z11.object({ actionID: z11.string(), choice: unknownChoiceSchema })),
743
805
  answerProposals: signedIn.errors(reusedIDErrors).input(batchInputSchema).output(batchResultSchema)
744
806
  };
745
807
 
@@ -782,6 +844,11 @@ var challengeForSchema = z13.discriminatedUnion("kind", [
782
844
  choice: choiceSchema,
783
845
  ruleHash: z13.string().optional()
784
846
  }),
847
+ z13.object({
848
+ kind: z13.literal("unknown_outcome"),
849
+ actionID: z13.string().min(1).max(200),
850
+ choice: z13.literal("retry")
851
+ }),
785
852
  z13.object({ kind: z13.literal("register") }),
786
853
  z13.object({ kind: z13.literal("revoke"), passkeyID: z13.string().min(1).max(200) })
787
854
  ]);
@@ -958,9 +1025,31 @@ var ruleChange = signedIn.errors(reusedIDErrors).errors({
958
1025
  NOT_ALLOWED: {
959
1026
  message: "The rule takes no such change",
960
1027
  status: 403,
961
- data: z23.object({ reason: z23.enum(["widens", "empty"]) })
1028
+ data: z23.object({ reason: z23.enum(["widens", "empty", "mandate"]) })
962
1029
  }
963
1030
  });
1031
+ var currentHashSchema = z23.object({ current: z23.object({ actionHash: z23.string() }) });
1032
+ var closedStateSchema = z23.object({
1033
+ state: z23.enum(["approved", "declined", "lapsed", "withdrawn"])
1034
+ });
1035
+ var proposalIDSchema = z23.string().min(1).max(64);
1036
+ var ruleFormSchema = z23.record(z23.string(), z23.unknown());
1037
+ var mandateRuleSchema = z23.object({ ruleID: z23.string(), sentence: z23.string() });
1038
+ var mandateSchema = z23.object({
1039
+ mandateID: z23.string(),
1040
+ title: z23.string().nullable(),
1041
+ rules: z23.array(mandateRuleSchema),
1042
+ startedAt: z23.date(),
1043
+ expires: z23.date()
1044
+ });
1045
+ var faultsSchema = z23.object({ faults: z23.array(z23.string()) });
1046
+ var invalid = {
1047
+ INVALID: {
1048
+ message: "The rule or the mandate breaks the rule format or its limits",
1049
+ status: 400,
1050
+ data: faultsSchema
1051
+ }
1052
+ };
964
1053
  var destinationsSchema = z23.array(z23.string().regex(/^\S+$/u)).max(100);
965
1054
  var ruleContract = {
966
1055
  readRule: signedIn.errors(notFound).input(z23.object({ ruleID: ruleIDSchema })).output(ruleSchema),
@@ -970,7 +1059,34 @@ var ruleContract = {
970
1059
  revision: revisionSchema,
971
1060
  destinations: destinationsSchema,
972
1061
  clientActionID: z23.uuid()
973
- })).output(z23.object({ ruleID: z23.string(), revision: revisionSchema }))
1062
+ })).output(z23.object({ ruleID: z23.string(), revision: revisionSchema })),
1063
+ editProposedRule: signedIn.errors(reusedIDErrors).errors({
1064
+ ...invalid,
1065
+ NOT_FOUND: { message: "No proposed rule has this ID", status: 404 },
1066
+ CONFLICT: {
1067
+ message: "The proposed rule changed since the card showed it",
1068
+ status: 409,
1069
+ data: currentHashSchema
1070
+ },
1071
+ CLOSED: {
1072
+ message: "The proposed rule is no longer open",
1073
+ status: 409,
1074
+ data: closedStateSchema
1075
+ }
1076
+ }).input(z23.object({
1077
+ proposalID: proposalIDSchema,
1078
+ actionHash: z23.string(),
1079
+ rule: ruleFormSchema,
1080
+ clientActionID: z23.uuid()
1081
+ })).output(z23.object({ proposalID: z23.string() })),
1082
+ proposeMandate: signedIn.errors(reusedIDErrors).errors(invalid).input(z23.object({
1083
+ title: z23.string(),
1084
+ rules: z23.array(ruleFormSchema),
1085
+ expires: z23.string().optional(),
1086
+ clientActionID: z23.uuid()
1087
+ })).output(z23.object({ proposalID: z23.string(), mandateID: z23.string(), expires: z23.date() })),
1088
+ listMandates: signedIn.output(z23.object({ mandates: z23.array(mandateSchema) })),
1089
+ endMandate: signedIn.errors(reusedIDErrors).errors({ NOT_FOUND: { message: "No mandate has this ID", status: 404 } }).input(z23.object({ mandateID: z23.string().min(1).max(64), clientActionID: z23.uuid() })).output(z23.object({ mandateID: z23.string(), state: z23.enum(["ended", "expired"]) }))
974
1090
  };
975
1091
 
976
1092
  // src/contract/task-schema.ts
@@ -1086,6 +1202,7 @@ var recordSchema = z26.object({
1086
1202
  proposal: z26.object({ proposalID: z26.string(), shortID: z26.string() }).optional(),
1087
1203
  recall: recallSchema.optional(),
1088
1204
  recordedAt: z26.date(),
1205
+ removal: z26.object({ kind: z26.string(), sequence: sequenceSchema, callSequence: sequenceSchema.optional() }).optional(),
1089
1206
  sequence: sequenceSchema,
1090
1207
  stop: z26.object({ cancelledActions: z26.array(listedActionSchema) }).optional(),
1091
1208
  summary: summarySchema.optional(),
@@ -1127,12 +1244,15 @@ var listedTaskSchema = z26.object({
1127
1244
  started: actionCountSchema
1128
1245
  }),
1129
1246
  brief: z26.string(),
1247
+ closedBy: z26.enum(["owner", "nixie", "disposable"]).optional(),
1130
1248
  controls: z26.array(taskControlSchema),
1249
+ disposable: z26.boolean().nullable(),
1131
1250
  isPauseRequested: z26.boolean(),
1132
1251
  isPausedByNixie: z26.boolean(),
1133
1252
  isTakingMessages: z26.boolean(),
1134
1253
  lastActivityAt: z26.date(),
1135
1254
  name: z26.string(),
1255
+ runner: z26.string(),
1136
1256
  state: taskStateSchema2,
1137
1257
  taskID: threadSchema,
1138
1258
  waitingOn: threadSchema.optional()
@@ -1149,8 +1269,17 @@ var taskControl = checkedAction.errors({
1149
1269
  message: "The task is in a state that does not take this control",
1150
1270
  status: 409,
1151
1271
  data: z26.object({ isPauseRequested: z26.boolean(), state: taskStateSchema2 })
1272
+ },
1273
+ RUNNER_LACKS_CONTROL: {
1274
+ message: "The runner of the task does not take this control",
1275
+ status: 409
1152
1276
  }
1153
1277
  }).input(z26.object({ clientActionID: clientActionIDSchema2, taskID: threadSchema })).output(controlledTaskSchema);
1278
+ var markedTaskSchema = z26.object({
1279
+ changedAt: z26.date(),
1280
+ disposable: z26.boolean(),
1281
+ taskID: threadSchema
1282
+ });
1154
1283
  var nixieControl = checkedAction.input(z26.object({ clientActionID: clientActionIDSchema2 })).output(z26.object({ paused: pauseStateSchema }));
1155
1284
  var backupNoticeSchema = z26.object({
1156
1285
  cause: z26.enum(["failed", "missing"]),
@@ -1224,7 +1353,20 @@ var contract = {
1224
1353
  close: taskControl.errors({
1225
1354
  CONVERSATION_NEVER_CLOSES: { message: "The conversation is never closed", status: 409 }
1226
1355
  }),
1227
- interrupt: taskControl
1356
+ interrupt: taskControl,
1357
+ setDisposable: checkedAction.errors({
1358
+ TASK_NOT_FOUND: { message: "No task has this ID", status: 404 },
1359
+ TASK_HAS_NO_MARK: { message: "The task has no disposable mark", status: 409 },
1360
+ TASK_STATE_REFUSED: {
1361
+ message: "The task is in a state that does not take this change",
1362
+ status: 409,
1363
+ data: z26.object({ state: taskStateSchema2 })
1364
+ }
1365
+ }).input(z26.object({
1366
+ clientActionID: clientActionIDSchema2,
1367
+ disposable: z26.boolean(),
1368
+ taskID: threadSchema
1369
+ })).output(markedTaskSchema)
1228
1370
  },
1229
1371
  memory: {
1230
1372
  readVersions: signedIn.input(z26.object({ versions: z26.array(versionRefSchema).min(1).max(100) })).output(z26.object({ versions: z26.array(versionTextSchema) })),
@@ -1279,8 +1421,8 @@ var contract = {
1279
1421
  }
1280
1422
  };
1281
1423
  // src/contract/host-contract.ts
1282
- import { oc as oc5 } from "@orpc/contract";
1283
- import { z as z33 } from "zod";
1424
+ import { oc as oc6 } from "@orpc/contract";
1425
+ import { z as z35 } from "zod";
1284
1426
 
1285
1427
  // src/contract/action-proposal-schema.ts
1286
1428
  import { z as z27 } from "zod";
@@ -1302,49 +1444,75 @@ var actionProposalSchema = z27.object({
1302
1444
  lapseAt: z27.date()
1303
1445
  });
1304
1446
 
1305
- // src/contract/host-passkey-contract.ts
1306
- import { oc as oc3 } from "@orpc/contract";
1447
+ // src/contract/forgotten-items-schema.ts
1307
1448
  import { z as z28 } from "zod";
1308
- var hostPasskeySchema = z28.object({
1309
- passkeyID: z28.string(),
1310
- label: z28.string(),
1311
- synced: z28.boolean(),
1312
- origin: z28.string(),
1313
- registeredBy: z28.string(),
1314
- authorizedBy: z28.string(),
1315
- registeredAt: z28.date(),
1316
- lastUsedAt: z28.date().nullable(),
1317
- revokedAt: z28.date().nullable()
1449
+ var forgottenItemsSchema = z28.object({
1450
+ itemIDs: z28.array(z28.string()),
1451
+ backup: forgetBackupSchema
1452
+ });
1453
+
1454
+ // src/contract/host-mandates-contract.ts
1455
+ import { oc as oc3 } from "@orpc/contract";
1456
+ import { z as z29 } from "zod";
1457
+ var mandates = oc3.errors({
1458
+ NOT_FOUND: { message: "no mandate has that ID", status: 404 }
1459
+ });
1460
+ var hostMandateRuleSchema = z29.object({ ruleID: z29.string(), sentence: z29.string() });
1461
+ var hostMandateSchema = z29.object({
1462
+ mandateID: z29.string(),
1463
+ title: z29.string().nullable(),
1464
+ rules: z29.array(hostMandateRuleSchema),
1465
+ startedAt: z29.date(),
1466
+ expires: z29.date()
1467
+ });
1468
+ var hostMandatesContract = {
1469
+ list: mandates.output(z29.array(hostMandateSchema)),
1470
+ end: mandates.input(z29.strictObject({ mandateID: z29.string().min(1) })).output(z29.object({ mandateID: z29.string(), state: z29.enum(["ended", "expired"]) }))
1471
+ };
1472
+
1473
+ // src/contract/host-passkey-contract.ts
1474
+ import { oc as oc4 } from "@orpc/contract";
1475
+ import { z as z30 } from "zod";
1476
+ var hostPasskeySchema = z30.object({
1477
+ passkeyID: z30.string(),
1478
+ label: z30.string(),
1479
+ synced: z30.boolean(),
1480
+ origin: z30.string(),
1481
+ registeredBy: z30.string(),
1482
+ authorizedBy: z30.string(),
1483
+ registeredAt: z30.date(),
1484
+ lastUsedAt: z30.date().nullable(),
1485
+ revokedAt: z30.date().nullable()
1318
1486
  });
1319
1487
  var hostPasskeyContract = {
1320
- issueCode: oc3.output(z28.object({ code: z28.string(), expiresAt: z28.date() })),
1321
- list: oc3.output(z28.array(hostPasskeySchema)),
1322
- revoke: oc3.errors({
1488
+ issueCode: oc4.output(z30.object({ code: z30.string(), expiresAt: z30.date() })),
1489
+ list: oc4.output(z30.array(hostPasskeySchema)),
1490
+ revoke: oc4.errors({
1323
1491
  PASSKEY_NOT_FOUND: { message: "no passkey has that ID", status: 404 }
1324
- }).input(z28.strictObject({ passkeyID: z28.string().min(1) })).output(z28.object({ passkeyID: z28.string(), revokedAt: z28.date() }))
1492
+ }).input(z30.strictObject({ passkeyID: z30.string().min(1) })).output(z30.object({ passkeyID: z30.string(), revokedAt: z30.date() }))
1325
1493
  };
1326
1494
 
1327
1495
  // src/contract/known-contact-schema.ts
1328
- import { z as z29 } from "zod";
1329
- var knownContactSchema = z29.object({
1330
- contactID: z29.string(),
1331
- name: z29.string().nullable(),
1332
- destination: z29.string().nullable(),
1333
- markedAt: z29.date()
1496
+ import { z as z31 } from "zod";
1497
+ var knownContactSchema = z31.object({
1498
+ contactID: z31.string(),
1499
+ name: z31.string().nullable(),
1500
+ destination: z31.string().nullable(),
1501
+ markedAt: z31.date()
1334
1502
  });
1335
1503
 
1336
1504
  // src/contract/turn-inputs-contract.ts
1337
- import { oc as oc4 } from "@orpc/contract";
1338
- import { z as z32 } from "zod";
1505
+ import { oc as oc5 } from "@orpc/contract";
1506
+ import { z as z34 } from "zod";
1339
1507
 
1340
1508
  // src/contract/input-miss-schema.ts
1341
- import { z as z30 } from "zod";
1342
- var inputMissSchema = z30.object({
1343
- missID: z30.string(),
1344
- captureID: z30.string().nullable(),
1345
- taskID: z30.string(),
1346
- stepRunID: z30.string(),
1347
- reason: z30.enum([
1509
+ import { z as z32 } from "zod";
1510
+ var inputMissSchema = z32.object({
1511
+ missID: z32.string(),
1512
+ captureID: z32.string().nullable(),
1513
+ taskID: z32.string(),
1514
+ stepRunID: z32.string(),
1515
+ reason: z32.enum([
1348
1516
  "queue_full",
1349
1517
  "spool_full",
1350
1518
  "spool_write_failed",
@@ -1356,46 +1524,46 @@ var inputMissSchema = z30.object({
1356
1524
  "intake_failed",
1357
1525
  "holds_own_value"
1358
1526
  ]),
1359
- count: z30.int().positive(),
1360
- writer: z30.string().nullable(),
1361
- counter: z30.int().nullable(),
1362
- createdAt: z30.date()
1527
+ count: z32.int().positive(),
1528
+ writer: z32.string().nullable(),
1529
+ counter: z32.int().nullable(),
1530
+ createdAt: z32.date()
1363
1531
  });
1364
1532
 
1365
1533
  // src/contract/logged-input-schema.ts
1366
- import { z as z31 } from "zod";
1367
- var loggedInputSchema = z31.object({
1368
- inputID: z31.string(),
1369
- captureID: z31.string(),
1370
- taskID: z31.string(),
1371
- stepRunID: z31.string(),
1372
- writer: z31.string(),
1373
- counter: z31.int(),
1374
- role: z31.string(),
1375
- profile: z31.string(),
1376
- model: z31.string(),
1377
- harness: z31.string(),
1378
- api: z31.string(),
1379
- endpoint: z31.string(),
1380
- route: z31.string(),
1381
- isRewritten: z31.boolean(),
1382
- upstreamStatus: z31.int(),
1383
- bytes: z31.int(),
1384
- intakeSequence: z31.int(),
1385
- receivedAt: z31.date(),
1386
- takenAt: z31.date(),
1387
- state: z31.enum(["writing", "stored", "missing", "removed"]),
1388
- removedCause: z31.enum(["retention_days", "retention_bytes", "forget", "dropped", "restore", "reset"]).nullable()
1534
+ import { z as z33 } from "zod";
1535
+ var loggedInputSchema = z33.object({
1536
+ inputID: z33.string(),
1537
+ captureID: z33.string(),
1538
+ taskID: z33.string(),
1539
+ stepRunID: z33.string(),
1540
+ writer: z33.string(),
1541
+ counter: z33.int(),
1542
+ role: z33.string(),
1543
+ profile: z33.string(),
1544
+ model: z33.string(),
1545
+ harness: z33.string(),
1546
+ api: z33.string(),
1547
+ endpoint: z33.string(),
1548
+ route: z33.string(),
1549
+ isRewritten: z33.boolean(),
1550
+ upstreamStatus: z33.int(),
1551
+ bytes: z33.int(),
1552
+ intakeSequence: z33.int(),
1553
+ receivedAt: z33.date(),
1554
+ takenAt: z33.date(),
1555
+ state: z33.enum(["writing", "stored", "missing", "removed"]),
1556
+ removedCause: z33.enum(["retention_days", "retention_bytes", "forget", "dropped", "restore", "reset"]).nullable()
1389
1557
  });
1390
1558
 
1391
1559
  // src/contract/turn-inputs-contract.ts
1392
- var turnInputOn = z32.strictObject({
1393
- state: z32.literal("on"),
1394
- forMs: z32.int().positive().nullable()
1560
+ var turnInputOn = z34.strictObject({
1561
+ state: z34.literal("on"),
1562
+ forMs: z34.int().positive().nullable()
1395
1563
  });
1396
- var turnInputOff = z32.strictObject({ state: z32.literal("off"), drop: z32.boolean() });
1397
- var turnInputSetSchema = z32.discriminatedUnion("state", [turnInputOn, turnInputOff]);
1398
- var turnInputs = oc4.errors({
1564
+ var turnInputOff = z34.strictObject({ state: z34.literal("off"), drop: z34.boolean() });
1565
+ var turnInputSetSchema = z34.discriminatedUnion("state", [turnInputOn, turnInputOff]);
1566
+ var turnInputs = oc5.errors({
1399
1567
  NOT_FOUND: { message: "no logged request has that ID", status: 404 },
1400
1568
  REMOVED: { message: "that request is removed or its body is missing", status: 410 },
1401
1569
  OPEN_NOT_RECORDED: {
@@ -1404,27 +1572,27 @@ var turnInputs = oc4.errors({
1404
1572
  },
1405
1573
  NOT_CONFIGURED: { message: "the turn-input log is not configured", status: 409 }
1406
1574
  });
1407
- var listedInputsSchema = z32.object({
1408
- inputs: z32.array(loggedInputSchema),
1409
- misses: z32.array(inputMissSchema)
1575
+ var listedInputsSchema = z34.object({
1576
+ inputs: z34.array(loggedInputSchema),
1577
+ misses: z34.array(inputMissSchema)
1410
1578
  });
1411
1579
  var turnInputsContract = {
1412
- list: turnInputs.input(z32.strictObject({ limit: z32.int().positive().max(500).default(50) })).output(listedInputsSchema),
1413
- open: turnInputs.input(z32.strictObject({ inputID: z32.string().min(1) })).output(z32.object({ inputID: z32.string(), body: z32.base64() })),
1414
- set: turnInputs.input(turnInputSetSchema).output(z32.object({ state: z32.enum(["on", "off"]), until: z32.number().nullable() }))
1580
+ list: turnInputs.input(z34.strictObject({ limit: z34.int().positive().max(500).default(50) })).output(listedInputsSchema),
1581
+ open: turnInputs.input(z34.strictObject({ inputID: z34.string().min(1) })).output(z34.object({ inputID: z34.string(), body: z34.base64() })),
1582
+ set: turnInputs.input(turnInputSetSchema).output(z34.object({ state: z34.enum(["on", "off"]), until: z34.number().nullable() }))
1415
1583
  };
1416
1584
 
1417
1585
  // src/contract/host-contract.ts
1418
- var versionRefSchema2 = z33.object({ itemID: z33.string(), version: z33.int().positive() });
1419
- var versionTargetSchema2 = z33.strictObject({
1420
- itemID: z33.string().min(1),
1421
- version: z33.int().positive()
1422
- });
1423
- var itemTextSchema = z33.string().max(2000).regex(/\S/u);
1424
- var proposalOriginSchema2 = z33.enum(["owner", "conversation", "task"]);
1425
- var memoryOriginSchema = z33.enum([...proposalOriginSchema2.options, "lapse"]);
1426
- var contentSourceSchema = z33.enum(["owner", "owner_data", "untrusted"]);
1427
- var reviewReasonSchema2 = z33.enum([
1586
+ var versionRefSchema2 = z35.object({ itemID: z35.string(), version: z35.int().positive() });
1587
+ var versionTargetSchema2 = z35.strictObject({
1588
+ itemID: z35.string().min(1),
1589
+ version: z35.int().positive()
1590
+ });
1591
+ var itemTextSchema = z35.string().max(2000).regex(/\S/u);
1592
+ var proposalOriginSchema2 = z35.enum(["owner", "conversation", "task"]);
1593
+ var memoryOriginSchema = z35.enum([...proposalOriginSchema2.options, "lapse"]);
1594
+ var contentSourceSchema = z35.enum(["owner", "owner_data", "untrusted"]);
1595
+ var reviewReasonSchema2 = z35.enum([
1428
1596
  "no_quote",
1429
1597
  "quote_not_typed",
1430
1598
  "quote_in_quoted_block",
@@ -1441,71 +1609,72 @@ var reviewReasonSchema2 = z33.enum([
1441
1609
  "from_photo",
1442
1610
  "sensitive",
1443
1611
  "subject_change",
1612
+ "labels",
1444
1613
  "ask_rule"
1445
1614
  ]);
1446
- var proposalSourceSchema2 = z33.object({
1615
+ var proposalSourceSchema2 = z35.object({
1447
1616
  origin: proposalOriginSchema2,
1448
- thread: z33.string().nullable(),
1449
- proposedAt: z33.date()
1450
- });
1451
- var pendingProposalSchema = z33.object({
1452
- proposalID: z33.string(),
1453
- operation: z33.enum(["remember", "retire", "pin"]),
1454
- itemID: z33.string(),
1455
- targetVersion: z33.int().nullable(),
1456
- isPinned: z33.boolean(),
1457
- subject: z33.enum(["owner", "self", "shared"]),
1458
- newSubject: z33.enum(["owner", "self", "shared"]).nullable(),
1459
- isSensitive: z33.boolean(),
1460
- kind: z33.enum(["fact", "self"]),
1617
+ thread: z35.string().nullable(),
1618
+ proposedAt: z35.date()
1619
+ });
1620
+ var pendingProposalSchema = z35.object({
1621
+ proposalID: z35.string(),
1622
+ operation: z35.enum(["remember", "retire", "pin"]),
1623
+ itemID: z35.string(),
1624
+ targetVersion: z35.int().nullable(),
1625
+ isPinned: z35.boolean(),
1626
+ subject: z35.enum(["owner", "self", "shared"]),
1627
+ newSubject: z35.enum(["owner", "self", "shared"]).nullable(),
1628
+ isSensitive: z35.boolean(),
1629
+ kind: z35.enum(["fact", "self"]),
1461
1630
  reason: reviewReasonSchema2,
1462
- actionHash: z33.string(),
1631
+ actionHash: z35.string(),
1463
1632
  origin: proposalOriginSchema2,
1464
1633
  source: contentSourceSchema,
1465
- createdAt: z33.date(),
1466
- lapseAt: z33.date(),
1467
- sources: z33.array(proposalSourceSchema2),
1468
- text: z33.string(),
1469
- quote: z33.string().nullable()
1470
- });
1471
- var closeMatchSchema2 = z33.object({ itemID: z33.string(), version: z33.int(), text: z33.string() });
1472
- var approvalResultSchema = z33.discriminatedUnion("status", [
1473
- z33.object({ status: z33.literal("applied"), itemID: z33.string(), version: z33.int() }),
1474
- z33.object({ status: z33.literal("close_match"), item: closeMatchSchema2 })
1634
+ createdAt: z35.date(),
1635
+ lapseAt: z35.date(),
1636
+ sources: z35.array(proposalSourceSchema2),
1637
+ text: z35.string(),
1638
+ quote: z35.string().nullable()
1639
+ });
1640
+ var closeMatchSchema2 = z35.object({ itemID: z35.string(), version: z35.int(), text: z35.string() });
1641
+ var approvalResultSchema = z35.discriminatedUnion("status", [
1642
+ z35.object({ status: z35.literal("applied"), itemID: z35.string(), version: z35.int() }),
1643
+ z35.object({ status: z35.literal("close_match"), item: closeMatchSchema2 })
1475
1644
  ]);
1476
- var historyVersionSchema = z33.object({
1477
- version: z33.int(),
1478
- change: z33.enum(["created", "edited", "retired", "restored", "undone"]),
1479
- state: z33.enum(["active", "retired"]),
1645
+ var historyVersionSchema = z35.object({
1646
+ version: z35.int(),
1647
+ change: z35.enum(["created", "edited", "retired", "restored", "undone"]),
1648
+ state: z35.enum(["active", "retired"]),
1480
1649
  origin: memoryOriginSchema,
1481
1650
  source: contentSourceSchema,
1482
- recordedAt: z33.date(),
1483
- status: z33.enum(["readable", "shredded", "unreadable"]),
1484
- text: z33.string().nullable()
1485
- });
1486
- var itemHistorySchema = z33.object({
1487
- itemID: z33.string(),
1488
- subject: z33.enum(["owner", "self", "shared"]),
1489
- kind: z33.enum(["fact", "self"]),
1490
- state: z33.enum(["active", "retired", "forgetting", "forgotten"]),
1491
- versions: z33.array(historyVersionSchema)
1492
- });
1493
- var proposalAnswerSchema = z33.strictObject({
1494
- proposalID: z33.string().min(1),
1495
- actionHash: z33.string().min(1)
1496
- });
1497
- var hostSessionSchema = z33.object({
1498
- sessionID: z33.string(),
1499
- deviceName: z33.string(),
1500
- createdAt: z33.date(),
1501
- lastUsedAt: z33.date()
1502
- });
1503
- var subjectCountSchema = z33.object({
1504
- owner: z33.int().nonnegative(),
1505
- shared: z33.int().nonnegative(),
1506
- self: z33.int().nonnegative()
1507
- });
1508
- var memory = oc5.errors({
1651
+ recordedAt: z35.date(),
1652
+ status: z35.enum(["readable", "shredded", "unreadable"]),
1653
+ text: z35.string().nullable()
1654
+ });
1655
+ var itemHistorySchema = z35.object({
1656
+ itemID: z35.string(),
1657
+ subject: z35.enum(["owner", "self", "shared"]),
1658
+ kind: z35.enum(["fact", "self"]),
1659
+ state: z35.enum(["active", "retired", "forgetting", "forgotten"]),
1660
+ versions: z35.array(historyVersionSchema)
1661
+ });
1662
+ var proposalAnswerSchema = z35.strictObject({
1663
+ proposalID: z35.string().min(1),
1664
+ actionHash: z35.string().min(1)
1665
+ });
1666
+ var hostSessionSchema = z35.object({
1667
+ sessionID: z35.string(),
1668
+ deviceName: z35.string(),
1669
+ createdAt: z35.date(),
1670
+ lastUsedAt: z35.date()
1671
+ });
1672
+ var subjectCountSchema = z35.object({
1673
+ owner: z35.int().nonnegative(),
1674
+ shared: z35.int().nonnegative(),
1675
+ self: z35.int().nonnegative()
1676
+ });
1677
+ var memory = oc6.errors({
1509
1678
  MEMORY_NOT_STARTED: { message: "the memory store has not started yet", status: 503 },
1510
1679
  NOT_FOUND: { message: "nothing has that ID", status: 404 },
1511
1680
  PROPOSAL_HASH: { message: "the action hash names another proposal", status: 409 },
@@ -1518,30 +1687,30 @@ var memory = oc5.errors({
1518
1687
  PIN_EDIT: { message: "a pin takes no edited text", status: 400 },
1519
1688
  SELF_NOTE_REFUSED: { message: "a self-note never takes that change", status: 409 }
1520
1689
  });
1521
- var skillFileSchema = z33.object({ path: z33.string(), text: z33.string() });
1522
- var pendingSkillProposalSchema = z33.object({
1523
- proposalID: z33.string(),
1524
- name: z33.string(),
1525
- skillHash: z33.string(),
1526
- baseHash: z33.string().nullable(),
1527
- files: z33.array(skillFileSchema),
1528
- inForce: z33.object({
1529
- skillHash: z33.string(),
1530
- origin: z33.enum(["definitions", "vendored", "nixie"]),
1531
- files: z33.array(skillFileSchema)
1690
+ var skillFileSchema = z35.object({ path: z35.string(), text: z35.string() });
1691
+ var pendingSkillProposalSchema = z35.object({
1692
+ proposalID: z35.string(),
1693
+ name: z35.string(),
1694
+ skillHash: z35.string(),
1695
+ baseHash: z35.string().nullable(),
1696
+ files: z35.array(skillFileSchema),
1697
+ inForce: z35.object({
1698
+ skillHash: z35.string(),
1699
+ origin: z35.enum(["definitions", "vendored", "nixie"]),
1700
+ files: z35.array(skillFileSchema)
1532
1701
  }).nullable(),
1533
- untypedToken: z33.object({ kind: z33.string(), raw: z33.string() }).nullable(),
1534
- thread: z33.string().nullable(),
1535
- provenance: z33.object({ runID: z33.string(), callID: z33.string(), profile: z33.string() }),
1536
- createdAt: z33.date(),
1537
- lapseAt: z33.date(),
1538
- isStale: z33.boolean()
1539
- });
1540
- var skillAnswerSchema = z33.strictObject({
1541
- proposalID: z33.string().min(1),
1542
- skillHash: z33.string().min(1)
1543
- });
1544
- var skills = oc5.errors({
1702
+ untypedToken: z35.object({ kind: z35.string(), raw: z35.string() }).nullable(),
1703
+ thread: z35.string().nullable(),
1704
+ provenance: z35.object({ runID: z35.string(), callID: z35.string(), profile: z35.string() }),
1705
+ createdAt: z35.date(),
1706
+ lapseAt: z35.date(),
1707
+ isStale: z35.boolean()
1708
+ });
1709
+ var skillAnswerSchema = z35.strictObject({
1710
+ proposalID: z35.string().min(1),
1711
+ skillHash: z35.string().min(1)
1712
+ });
1713
+ var skills = oc6.errors({
1545
1714
  NOT_FOUND: { message: "nothing has that ID", status: 404 },
1546
1715
  PROPOSAL_HASH: { message: "the skill hash names other files", status: 409 },
1547
1716
  PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
@@ -1549,103 +1718,99 @@ var skills = oc5.errors({
1549
1718
  SKILL_CHECK: { message: "the files fail the seed checks", status: 400 },
1550
1719
  WRONG_STATE: { message: "the skill nixie wrote is no longer in force", status: 409 }
1551
1720
  });
1552
- var definitionsSkillSchema = z33.object({ skillHash: z33.string(), origin: z33.enum(["definitions", "vendored"]) }).nullable();
1553
- var writtenSkillSchema = z33.object({
1554
- approvalID: z33.string(),
1555
- proposalID: z33.string(),
1556
- name: z33.string(),
1557
- skillHash: z33.string(),
1721
+ var definitionsSkillSchema = z35.object({ skillHash: z35.string(), origin: z35.enum(["definitions", "vendored"]) }).nullable();
1722
+ var writtenSkillSchema = z35.object({
1723
+ approvalID: z35.string(),
1724
+ proposalID: z35.string(),
1725
+ name: z35.string(),
1726
+ skillHash: z35.string(),
1558
1727
  base: definitionsSkillSchema,
1559
1728
  definitions: definitionsSkillSchema,
1560
- isConflict: z33.boolean(),
1561
- pullRequestURL: z33.url().nullable(),
1562
- approvedAt: z33.date()
1563
- });
1564
- var promptPartFileSchema = z33.object({ path: z33.string(), text: z33.string() });
1565
- var promptEntrySchema = z33.record(z33.string(), z33.string());
1566
- var pendingPromptProposalSchema = z33.object({
1567
- proposalID: z33.string(),
1568
- promptID: z33.string(),
1569
- proposalHash: z33.string(),
1570
- baseHash: z33.string().nullable(),
1729
+ isConflict: z35.boolean(),
1730
+ pullRequestURL: z35.url().nullable(),
1731
+ approvedAt: z35.date()
1732
+ });
1733
+ var promptPartFileSchema = z35.object({ path: z35.string(), text: z35.string() });
1734
+ var promptEntrySchema = z35.record(z35.string(), z35.string());
1735
+ var pendingPromptProposalSchema = z35.object({
1736
+ proposalID: z35.string(),
1737
+ promptID: z35.string(),
1738
+ proposalHash: z35.string(),
1739
+ baseHash: z35.string().nullable(),
1571
1740
  entry: promptEntrySchema,
1572
- files: z33.array(promptPartFileSchema),
1573
- reason: z33.string(),
1574
- inForce: z33.object({ parts: promptEntrySchema, template: z33.string().nullable() }).nullable(),
1575
- thread: z33.string().nullable(),
1576
- provenance: z33.object({ runID: z33.string(), callID: z33.string(), profile: z33.string() }),
1577
- createdAt: z33.date(),
1578
- lapseAt: z33.date(),
1579
- isStale: z33.boolean()
1580
- });
1581
- var promptAnswerSchema = z33.strictObject({
1582
- proposalID: z33.string().min(1),
1583
- proposalHash: z33.string().min(1)
1584
- });
1585
- var prompts = oc5.errors({
1741
+ files: z35.array(promptPartFileSchema),
1742
+ reason: z35.string(),
1743
+ inForce: z35.object({ parts: promptEntrySchema, template: z35.string().nullable() }).nullable(),
1744
+ thread: z35.string().nullable(),
1745
+ provenance: z35.object({ runID: z35.string(), callID: z35.string(), profile: z35.string() }),
1746
+ createdAt: z35.date(),
1747
+ lapseAt: z35.date(),
1748
+ isStale: z35.boolean()
1749
+ });
1750
+ var promptAnswerSchema = z35.strictObject({
1751
+ proposalID: z35.string().min(1),
1752
+ proposalHash: z35.string().min(1)
1753
+ });
1754
+ var prompts = oc6.errors({
1586
1755
  NOT_FOUND: { message: "nothing has that ID", status: 404 },
1587
1756
  PROPOSAL_HASH: { message: "the proposal hash names another override", status: 409 },
1588
1757
  PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
1589
1758
  STALE_BASE: { message: "the override in force moved past the proposal", status: 409 },
1590
1759
  PROMPT_CHECK: { message: "the override fails the definitions checks", status: 400 }
1591
1760
  });
1592
- var ruleVersionSchema = z33.object({ ruleHash: z33.string(), sentence: z33.string() }).nullable();
1593
- var ruleInForceSchema = z33.object({
1594
- ruleID: z33.string(),
1595
- revision: z33.int().positive(),
1596
- ruleHash: z33.string(),
1597
- sentence: z33.string(),
1598
- origin: z33.enum(["definitions", "nixie"]),
1599
- changeID: z33.string().nullable(),
1600
- lastFiredAt: z33.date().nullable()
1601
- });
1602
- var ruleConflictSchema = z33.object({
1603
- ruleID: z33.string(),
1604
- changeID: z33.string(),
1761
+ var ruleVersionSchema = z35.object({ ruleHash: z35.string(), sentence: z35.string() }).nullable();
1762
+ var ruleInForceSchema = z35.object({
1763
+ ruleID: z35.string(),
1764
+ revision: z35.int().positive(),
1765
+ ruleHash: z35.string(),
1766
+ sentence: z35.string(),
1767
+ origin: z35.enum(["definitions", "nixie"]),
1768
+ changeID: z35.string().nullable(),
1769
+ lastFiredAt: z35.date().nullable()
1770
+ });
1771
+ var ruleConflictSchema = z35.object({
1772
+ ruleID: z35.string(),
1773
+ changeID: z35.string(),
1605
1774
  nixie: ruleVersionSchema,
1606
1775
  repo: ruleVersionSchema,
1607
1776
  base: ruleVersionSchema,
1608
- changedBy: z33.enum(["owner", "nixie"]),
1609
- reason: z33.string(),
1610
- changedAt: z33.date()
1777
+ changedBy: z35.enum(["owner", "nixie"]),
1778
+ reason: z35.string(),
1779
+ changedAt: z35.date()
1611
1780
  });
1612
- var ruleProposalChangeSchema = z33.object({
1613
- ruleID: z33.string(),
1781
+ var ruleProposalChangeSchema = z35.object({
1782
+ ruleID: z35.string(),
1614
1783
  before: ruleVersionSchema,
1615
1784
  after: ruleVersionSchema
1616
1785
  });
1617
- var effectChangeSchema = z33.object({
1618
- tool: z33.string(),
1619
- remove: z33.array(z33.string()),
1620
- sentence: z33.string()
1786
+ var effectChangeSchema = z35.object({
1787
+ tool: z35.string(),
1788
+ remove: z35.array(z35.string()),
1789
+ sentence: z35.string()
1621
1790
  });
1622
- var pendingRuleProposalSchema = z33.object({
1623
- proposalID: z33.string(),
1624
- changes: z33.array(ruleProposalChangeSchema),
1625
- effectChanges: z33.array(effectChangeSchema),
1626
- createdAt: z33.date(),
1627
- lapseAt: z33.date()
1791
+ var pendingRuleProposalSchema = z35.object({
1792
+ proposalID: z35.string(),
1793
+ changes: z35.array(ruleProposalChangeSchema),
1794
+ effectChanges: z35.array(effectChangeSchema),
1795
+ createdAt: z35.date(),
1796
+ lapseAt: z35.date()
1628
1797
  });
1629
- var ruleProposalAnswerSchema = z33.strictObject({ proposalID: z33.string().min(1) });
1798
+ var ruleProposalAnswerSchema = z35.strictObject({ proposalID: z35.string().min(1) });
1630
1799
  var ruleProposalRejectionSchema = ruleProposalAnswerSchema.extend({
1631
- reason: z33.string().max(500).regex(/\S/u)
1800
+ reason: z35.string().max(500).regex(/\S/u)
1632
1801
  });
1633
1802
  var actionRejectionSchema = ruleProposalAnswerSchema.extend({
1634
- reason: z33.string().max(500).regex(/\S/u).optional()
1803
+ reason: z35.string().max(500).regex(/\S/u).optional()
1635
1804
  });
1636
1805
  var ruleProposalErrors = {
1637
1806
  NOT_FOUND: { message: "nothing has that ID", status: 404 },
1638
1807
  PROPOSAL_CLOSED: { message: "the proposal is answered, withdrawn or lapsed", status: 409 }
1639
1808
  };
1640
- var rules = oc5.errors(ruleProposalErrors);
1641
- var contacts = oc5.errors({
1809
+ var rules = oc6.errors(ruleProposalErrors);
1810
+ var contacts = oc6.errors({
1642
1811
  NOT_FOUND: { message: "no known contact has that ID", status: 404 }
1643
1812
  });
1644
- var forgottenItemsSchema = z33.object({
1645
- itemIDs: z33.array(z33.string()),
1646
- backup: forgetBackupSchema
1647
- });
1648
- var hostTaskStateSchema = z33.enum([
1813
+ var hostTaskStateSchema = z35.enum([
1649
1814
  "ready",
1650
1815
  "running",
1651
1816
  "waiting",
@@ -1655,35 +1820,39 @@ var hostTaskStateSchema = z33.enum([
1655
1820
  "failed",
1656
1821
  "closed"
1657
1822
  ]);
1658
- var taskControl2 = oc5.errors({
1823
+ var taskControl2 = oc6.errors({
1659
1824
  TASK_NOT_FOUND: { message: "no task has that ID", status: 404 },
1660
1825
  TASK_STATE_REFUSED: {
1661
1826
  message: "the task is in a state that does not take this control",
1662
1827
  status: 409
1828
+ },
1829
+ RUNNER_LACKS_CONTROL: {
1830
+ message: "the runner of the task does not take this control",
1831
+ status: 409
1663
1832
  }
1664
- }).input(z33.strictObject({ taskID: z33.string().min(1) })).output(z33.object({
1665
- taskID: z33.string(),
1833
+ }).input(z35.strictObject({ taskID: z35.string().min(1) })).output(z35.object({
1834
+ taskID: z35.string(),
1666
1835
  state: hostTaskStateSchema,
1667
- isPauseRequested: z33.boolean()
1836
+ isPauseRequested: z35.boolean()
1668
1837
  }));
1669
1838
  var hostContract = {
1670
- reset: oc5.output(z33.object({
1671
- resetAt: z33.date(),
1672
- lastSequence: z33.int().nonnegative(),
1673
- keptSessions: z33.int().nonnegative()
1839
+ reset: oc6.output(z35.object({
1840
+ resetAt: z35.date(),
1841
+ lastSequence: z35.int().nonnegative(),
1842
+ keptSessions: z35.int().nonnegative()
1674
1843
  })),
1675
- resetConversations: oc5.output(z33.object({
1676
- resetAt: z33.date(),
1677
- lastSequence: z33.int().nonnegative(),
1678
- shreddedRecords: z33.int().nonnegative(),
1844
+ resetConversations: oc6.output(z35.object({
1845
+ resetAt: z35.date(),
1846
+ lastSequence: z35.int().nonnegative(),
1847
+ shreddedRecords: z35.int().nonnegative(),
1679
1848
  backup: forgetBackupSchema
1680
1849
  })),
1681
1850
  nixie: {
1682
- pause: oc5.output(z33.object({ paused: pauseStateSchema })),
1683
- resume: oc5.output(z33.object({ paused: pauseStateSchema }))
1851
+ pause: oc6.output(z35.object({ paused: pauseStateSchema })),
1852
+ resume: oc6.output(z35.object({ paused: pauseStateSchema }))
1684
1853
  },
1685
1854
  recovery: {
1686
- read: oc5.output(z33.object({ recovery: recoverySchema }))
1855
+ read: oc6.output(z35.object({ recovery: recoverySchema }))
1687
1856
  },
1688
1857
  tasks: {
1689
1858
  pause: taskControl2,
@@ -1694,105 +1863,106 @@ var hostContract = {
1694
1863
  CONVERSATION_NEVER_CLOSES: { message: "the conversation is never closed", status: 409 }
1695
1864
  }),
1696
1865
  interrupt: taskControl2,
1697
- raise: oc5.errors({
1866
+ raise: oc6.errors({
1698
1867
  TASK_NOT_FOUND: { message: "no task has that ID", status: 404 },
1699
1868
  TASK_NOT_AT_LIMIT: { message: "the task is not paused at its limit", status: 409 },
1700
1869
  LIMIT_NOT_RAISED: { message: "the new limits are not above the old ones", status: 409 }
1701
- }).input(z33.strictObject({
1702
- taskID: z33.string().min(1),
1703
- turns: z33.int().positive().optional(),
1704
- dollars: z33.number().positive().optional()
1870
+ }).input(z35.strictObject({
1871
+ taskID: z35.string().min(1),
1872
+ turns: z35.int().positive().optional(),
1873
+ dollars: z35.number().positive().optional()
1705
1874
  }).refine((input) => input.turns !== undefined || input.dollars !== undefined, {
1706
1875
  message: "a raise sets turns, dollars or both"
1707
- })).output(z33.object({
1708
- taskID: z33.string(),
1876
+ })).output(z35.object({
1877
+ taskID: z35.string(),
1709
1878
  state: hostTaskStateSchema,
1710
- isPauseRequested: z33.boolean(),
1711
- turns: z33.int().positive(),
1712
- dollars: z33.number().positive()
1879
+ isPauseRequested: z35.boolean(),
1880
+ turns: z35.int().positive(),
1881
+ dollars: z35.number().positive()
1713
1882
  }))
1714
1883
  },
1715
1884
  sessions: {
1716
- issueCode: oc5.output(z33.object({ code: z33.string(), expiresAt: z33.date() })),
1717
- list: oc5.output(z33.array(hostSessionSchema)),
1718
- label: oc5.errors({
1885
+ issueCode: oc6.output(z35.object({ code: z35.string(), expiresAt: z35.date() })),
1886
+ list: oc6.output(z35.array(hostSessionSchema)),
1887
+ label: oc6.errors({
1719
1888
  SESSION_NOT_FOUND: {
1720
1889
  message: "no device session that is still signed in has that ID",
1721
1890
  status: 404
1722
1891
  },
1723
1892
  LABEL_INVALID: { message: "a label holds 1 to 100 characters besides spaces", status: 400 }
1724
- }).input(z33.strictObject({ sessionID: z33.string().min(1), label: z33.string() })).output(z33.object({ sessionID: z33.string(), label: z33.string() }))
1893
+ }).input(z35.strictObject({ sessionID: z35.string().min(1), label: z35.string() })).output(z35.object({ sessionID: z35.string(), label: z35.string() }))
1725
1894
  },
1726
1895
  passkeys: hostPasskeyContract,
1727
1896
  memory: {
1728
1897
  proposals: {
1729
- list: memory.output(z33.array(pendingProposalSchema)),
1898
+ list: memory.output(z35.array(pendingProposalSchema)),
1730
1899
  approve: memory.input(proposalAnswerSchema.extend({
1731
1900
  revisionOf: versionTargetSchema2.optional(),
1732
- ignoreCloseMatch: z33.boolean().optional(),
1901
+ ignoreCloseMatch: z35.boolean().optional(),
1733
1902
  editedText: itemTextSchema.optional()
1734
1903
  })).output(approvalResultSchema),
1735
- reject: memory.input(proposalAnswerSchema.extend({ reason: z33.string().max(500).regex(/\S/u).optional() })).output(z33.object({ proposalID: z33.string() }))
1904
+ reject: memory.input(proposalAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u).optional() })).output(z35.object({ proposalID: z35.string() }))
1736
1905
  },
1737
- subjects: memory.output(z33.object({ items: subjectCountSchema, proposals: subjectCountSchema })),
1906
+ subjects: memory.output(z35.object({ items: subjectCountSchema, proposals: subjectCountSchema })),
1738
1907
  items: {
1739
- read: memory.input(z33.strictObject({ itemID: z33.string().min(1) })).output(itemHistorySchema),
1908
+ read: memory.input(z35.strictObject({ itemID: z35.string().min(1) })).output(itemHistorySchema),
1740
1909
  edit: memory.input(versionTargetSchema2.extend({ text: itemTextSchema })).output(versionRefSchema2),
1741
1910
  retire: memory.input(versionTargetSchema2).output(versionRefSchema2),
1742
1911
  restore: memory.input(versionTargetSchema2).output(versionRefSchema2),
1743
- forget: memory.input(versionTargetSchema2).output(z33.object({ itemID: z33.string(), backup: forgetBackupSchema })),
1912
+ forget: memory.input(versionTargetSchema2).output(z35.object({ itemID: z35.string(), backup: forgetBackupSchema })),
1744
1913
  forgetAll: memory.output(forgottenItemsSchema),
1745
- pin: memory.input(z33.strictObject({ itemID: z33.string().min(1), isPinned: z33.boolean() })).output(z33.object({ itemID: z33.string(), isPinned: z33.boolean() }))
1914
+ pin: memory.input(z35.strictObject({ itemID: z35.string().min(1), isPinned: z35.boolean() })).output(z35.object({ itemID: z35.string(), isPinned: z35.boolean() }))
1746
1915
  }
1747
1916
  },
1748
1917
  skills: {
1749
1918
  proposals: {
1750
- list: skills.output(z33.array(pendingSkillProposalSchema)),
1751
- approve: skills.input(skillAnswerSchema.extend({ files: z33.array(skillFileSchema).min(1).optional() })).output(z33.object({ proposalID: z33.string(), approvalID: z33.string(), skillHash: z33.string() })),
1752
- reject: skills.input(skillAnswerSchema.extend({ reason: z33.string().max(500).regex(/\S/u) })).output(z33.object({ proposalID: z33.string() }))
1919
+ list: skills.output(z35.array(pendingSkillProposalSchema)),
1920
+ approve: skills.input(skillAnswerSchema.extend({ files: z35.array(skillFileSchema).min(1).optional() })).output(z35.object({ proposalID: z35.string(), approvalID: z35.string(), skillHash: z35.string() })),
1921
+ reject: skills.input(skillAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u) })).output(z35.object({ proposalID: z35.string() }))
1753
1922
  },
1754
1923
  written: {
1755
- list: skills.output(z33.array(writtenSkillSchema)),
1756
- resolve: skills.input(z33.strictObject({
1757
- approvalID: z33.string().min(1),
1758
- keep: z33.enum(["nixie", "definitions"])
1759
- })).output(z33.object({ approvalID: z33.string(), keep: z33.enum(["nixie", "definitions"]) }))
1924
+ list: skills.output(z35.array(writtenSkillSchema)),
1925
+ resolve: skills.input(z35.strictObject({
1926
+ approvalID: z35.string().min(1),
1927
+ keep: z35.enum(["nixie", "definitions"])
1928
+ })).output(z35.object({ approvalID: z35.string(), keep: z35.enum(["nixie", "definitions"]) }))
1760
1929
  }
1761
1930
  },
1762
1931
  rules: {
1763
- list: rules.output(z33.array(ruleInForceSchema)),
1764
- conflicts: rules.output(z33.array(ruleConflictSchema)),
1765
- resolve: rules.input(z33.strictObject({ ruleID: z33.string().min(1), keep: z33.enum(["nixie", "repo"]) })).output(z33.object({ ruleID: z33.string(), changeID: z33.string(), keep: z33.enum(["nixie", "repo"]) })),
1932
+ list: rules.output(z35.array(ruleInForceSchema)),
1933
+ conflicts: rules.output(z35.array(ruleConflictSchema)),
1934
+ resolve: rules.input(z35.strictObject({ ruleID: z35.string().min(1), keep: z35.enum(["nixie", "repo"]) })).output(z35.object({ ruleID: z35.string(), changeID: z35.string(), keep: z35.enum(["nixie", "repo"]) })),
1766
1935
  proposals: {
1767
- list: rules.output(z33.array(pendingRuleProposalSchema)),
1768
- approve: rules.input(ruleProposalAnswerSchema).output(z33.object({ proposalID: z33.string() })),
1769
- reject: rules.input(ruleProposalRejectionSchema).output(z33.object({ proposalID: z33.string() }))
1936
+ list: rules.output(z35.array(pendingRuleProposalSchema)),
1937
+ approve: rules.input(ruleProposalAnswerSchema).output(z35.object({ proposalID: z35.string() })),
1938
+ reject: rules.input(ruleProposalRejectionSchema).output(z35.object({ proposalID: z35.string() }))
1770
1939
  }
1771
1940
  },
1772
1941
  actions: {
1773
1942
  proposals: {
1774
- list: rules.output(z33.array(actionProposalSchema)),
1775
- approve: rules.input(ruleProposalAnswerSchema).output(z33.object({ proposalID: z33.string() })),
1776
- reject: rules.input(actionRejectionSchema).output(z33.object({ proposalID: z33.string() }))
1943
+ list: rules.output(z35.array(actionProposalSchema)),
1944
+ approve: rules.input(ruleProposalAnswerSchema).output(z35.object({ proposalID: z35.string() })),
1945
+ reject: rules.input(actionRejectionSchema).output(z35.object({ proposalID: z35.string() }))
1777
1946
  }
1778
1947
  },
1948
+ mandates: hostMandatesContract,
1779
1949
  contacts: {
1780
- list: contacts.output(z33.array(knownContactSchema)),
1781
- markKnown: contacts.input(z33.strictObject({
1782
- destination: z33.string().min(1).max(500),
1783
- name: z33.string().min(1).max(200).optional()
1784
- })).output(z33.object({ contact: knownContactSchema, isNew: z33.boolean() })),
1785
- unmark: contacts.input(z33.strictObject({ contactID: z33.string().min(1) })).output(z33.object({ contactID: z33.string() }))
1950
+ list: contacts.output(z35.array(knownContactSchema)),
1951
+ markKnown: contacts.input(z35.strictObject({
1952
+ destination: z35.string().min(1).max(500),
1953
+ name: z35.string().min(1).max(200).optional()
1954
+ })).output(z35.object({ contact: knownContactSchema, isNew: z35.boolean() })),
1955
+ unmark: contacts.input(z35.strictObject({ contactID: z35.string().min(1) })).output(z35.object({ contactID: z35.string() }))
1786
1956
  },
1787
1957
  turnInputs: turnInputsContract,
1788
1958
  prompts: {
1789
1959
  proposals: {
1790
- list: prompts.output(z33.array(pendingPromptProposalSchema)),
1960
+ list: prompts.output(z35.array(pendingPromptProposalSchema)),
1791
1961
  approve: prompts.input(promptAnswerSchema.extend({
1792
1962
  entry: promptEntrySchema.optional(),
1793
- files: z33.array(promptPartFileSchema).optional()
1794
- })).output(z33.object({ proposalID: z33.string(), approvalID: z33.string(), proposalHash: z33.string() })),
1795
- reject: prompts.input(promptAnswerSchema.extend({ reason: z33.string().max(500).regex(/\S/u) })).output(z33.object({ proposalID: z33.string() }))
1963
+ files: z35.array(promptPartFileSchema).optional()
1964
+ })).output(z35.object({ proposalID: z35.string(), approvalID: z35.string(), proposalHash: z35.string() })),
1965
+ reject: prompts.input(promptAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u) })).output(z35.object({ proposalID: z35.string() }))
1796
1966
  }
1797
1967
  }
1798
1968
  };
@@ -1804,6 +1974,52 @@ function isTimeZone(zone) {
1804
1974
  return false;
1805
1975
  }
1806
1976
  }
1977
+ // src/contract/schedule-schema.ts
1978
+ import { z as z36 } from "zod";
1979
+ var clockTimeSchema = z36.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/u, "a time is HH:MM, 24-hour");
1980
+ var minutesSchema = z36.strictObject({
1981
+ minutes: z36.int().min(5).max(1440)
1982
+ });
1983
+ var weekdaySchema = z36.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]);
1984
+ var scheduleSchema = z36.strictObject({
1985
+ every: z36.union([z36.enum(["day", "week", "hour"]), minutesSchema]),
1986
+ at: clockTimeSchema.optional(),
1987
+ on: weekdaySchema.optional(),
1988
+ window: z36.strictObject({ from: clockTimeSchema, until: clockTimeSchema }).optional(),
1989
+ idleMinutes: z36.int().min(1).max(720).optional(),
1990
+ zone: z36.string().refine((zone) => zone === "owner" || isTimeZone(zone), "a zone is owner or an IANA zone").default("owner"),
1991
+ catchUp: z36.enum(["once", "skip"]).default("once")
1992
+ }).superRefine((schedule, context) => {
1993
+ const isCalendar = schedule.every === "day" || schedule.every === "week";
1994
+ if (isCalendar && schedule.at === undefined && schedule.window === undefined) {
1995
+ context.addIssue({ code: "custom", message: "day and week need at or window" });
1996
+ }
1997
+ if (isCalendar && schedule.at !== undefined && schedule.window !== undefined) {
1998
+ context.addIssue({ code: "custom", message: "at and window never come together" });
1999
+ }
2000
+ if (!isCalendar && schedule.at !== undefined) {
2001
+ context.addIssue({ code: "custom", message: "hour and minutes schedules take no at" });
2002
+ }
2003
+ if (!isCalendar && schedule.window !== undefined) {
2004
+ context.addIssue({ code: "custom", message: "hour and minutes schedules take no window" });
2005
+ }
2006
+ if (schedule.every === "week" && schedule.on === undefined) {
2007
+ context.addIssue({ code: "custom", message: "a week schedule needs on" });
2008
+ }
2009
+ if (schedule.every !== "week" && schedule.on !== undefined) {
2010
+ context.addIssue({ code: "custom", message: "only a week schedule takes on" });
2011
+ }
2012
+ if (schedule.idleMinutes !== undefined && schedule.window === undefined) {
2013
+ context.addIssue({ code: "custom", message: "idleMinutes needs window" });
2014
+ }
2015
+ });
2016
+ // src/contract/trigger-schema.ts
2017
+ import { z as z37 } from "zod";
2018
+ var triggerAtSchema = z37.iso.datetime({ offset: true });
2019
+ var triggerSchema = z37.union([
2020
+ z37.strictObject({ schedule: scheduleSchema }),
2021
+ z37.strictObject({ at: triggerAtSchema })
2022
+ ]);
1807
2023
  // src/contract/session-cookie-name.ts
1808
2024
  var sessionCookieName = "nixie_session";
1809
2025
 
@@ -1814,11 +2030,11 @@ function renderSessionCookie(token) {
1814
2030
  return `${sessionCookieName}=${token ?? ""}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${maxAgeS}`;
1815
2031
  }
1816
2032
  // src/message/task-message-input-schema.ts
1817
- import { z as z35 } from "zod";
2033
+ import { z as z39 } from "zod";
1818
2034
 
1819
2035
  // src/message/task-message-kind-schema.ts
1820
- import { z as z34 } from "zod";
1821
- var taskMessageKindSchema = z34.enum([
2036
+ import { z as z38 } from "zod";
2037
+ var taskMessageKindSchema = z38.enum([
1822
2038
  "progress",
1823
2039
  "question",
1824
2040
  "request",
@@ -1828,21 +2044,21 @@ var taskMessageKindSchema = z34.enum([
1828
2044
  ]);
1829
2045
 
1830
2046
  // src/message/task-message-input-schema.ts
1831
- var taskMessageInputSchema = z35.object({
1832
- to: z35.string(),
2047
+ var taskMessageInputSchema = z39.object({
2048
+ to: z39.string(),
1833
2049
  kind: taskMessageKindSchema,
1834
- body: z35.string(),
1835
- replyTo: z35.string().optional(),
1836
- onBehalfOf: z35.string().array().optional(),
1837
- wake: z35.boolean().optional()
2050
+ body: z39.string(),
2051
+ replyTo: z39.string().optional(),
2052
+ onBehalfOf: z39.string().array().optional(),
2053
+ wake: z39.boolean().optional()
1838
2054
  });
1839
2055
  // src/message/task-message-result-schema.ts
1840
- import { z as z36 } from "zod";
1841
- var taskMessageResultSchema = z36.object({
1842
- messageID: z36.string(),
1843
- woke: z36.boolean(),
1844
- hop: z36.int().nonnegative(),
1845
- note: z36.string().optional()
2056
+ import { z as z40 } from "zod";
2057
+ var taskMessageResultSchema = z40.object({
2058
+ messageID: z40.string(),
2059
+ woke: z40.boolean(),
2060
+ hop: z40.int().nonnegative(),
2061
+ note: z40.string().optional()
1846
2062
  });
1847
2063
  export {
1848
2064
  buildPendingInput,
@@ -1856,9 +2072,12 @@ export {
1856
2072
  isTimeZone,
1857
2073
  pickSpanSource,
1858
2074
  renderSessionCookie,
2075
+ scheduleSchema,
1859
2076
  sessionCookieName,
1860
2077
  spanSchema,
1861
2078
  taskMessageInputSchema,
1862
2079
  taskMessageKindSchema,
1863
- taskMessageResultSchema
2080
+ taskMessageResultSchema,
2081
+ triggerAtSchema,
2082
+ triggerSchema
1864
2083
  };