@openrig/cli 0.1.11 → 0.2.0

package/daemon/dist/db/migrations/029_classifier_leases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"029_classifier_leases.js","sourceRoot":"","sources":["../../../src/db/migrations/029_classifier_leases.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAc;IAC/C,IAAI,EAAE,2BAA2B;IACjC,GAAG,EAAE;;;;;;;;;;;;;;;;;GAiBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/030_views_custom.d.ts

@@ -0,0 +1,15 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Custom views (PL-004 Phase B; L5 View — custom-view registration table).
+ *
+ * Per PRD § L5: built-in views (`recently-active`, `founder`, `pod-load`,
+ * `escalations`, `held`, `activity`) are HARDCODED in view-projector.ts.
+ * Operator-defined custom views are stored in this table and registered at
+ * daemon startup from `~/.openrig/views.yaml` (or via API at runtime).
+ *
+ * Built-in views are NOT inserted into this table — view-projector.ts
+ * exposes them by name without DB lookup. Custom views are looked up here
+ * when the operator queries `rig view show <custom-name>`.
+ */
+export declare const viewsCustomSchema: Migration;
+//# sourceMappingURL=030_views_custom.d.ts.map

package/daemon/dist/db/migrations/030_views_custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"030_views_custom.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/030_views_custom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAa/B,CAAC"}

package/daemon/dist/db/migrations/030_views_custom.js

@@ -0,0 +1,27 @@
+/**
+ * Custom views (PL-004 Phase B; L5 View — custom-view registration table).
+ *
+ * Per PRD § L5: built-in views (`recently-active`, `founder`, `pod-load`,
+ * `escalations`, `held`, `activity`) are HARDCODED in view-projector.ts.
+ * Operator-defined custom views are stored in this table and registered at
+ * daemon startup from `~/.openrig/views.yaml` (or via API at runtime).
+ *
+ * Built-in views are NOT inserted into this table — view-projector.ts
+ * exposes them by name without DB lookup. Custom views are looked up here
+ * when the operator queries `rig view show <custom-name>`.
+ */
+export const viewsCustomSchema = {
+    name: "030_views_custom.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS views_custom (
+      view_id TEXT PRIMARY KEY,
+      view_name TEXT NOT NULL UNIQUE,
+      definition TEXT NOT NULL,
+      registered_by_session TEXT NOT NULL,
+      registered_at TEXT NOT NULL,
+      last_evaluated_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_views_custom_registered_by ON views_custom(registered_by_session);
+  `,
+};
+//# sourceMappingURL=030_views_custom.js.map

package/daemon/dist/db/migrations/030_views_custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"030_views_custom.js","sourceRoot":"","sources":["../../../src/db/migrations/030_views_custom.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAc;IAC1C,IAAI,EAAE,sBAAsB;IAC5B,GAAG,EAAE;;;;;;;;;;GAUJ;CACF,CAAC"}

package/daemon/dist/db/migrations/031_watchdog_jobs.d.ts

@@ -0,0 +1,34 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Watchdog jobs (PL-004 Phase C; daemon-native Watchdog supervision tree).
+ *
+ * Per PRD § Watchdog + slice IMPL § Write Set: SQLite-canonical watchdog
+ * jobs that join the daemon supervision tree. Three policy enum values
+ * SHIPPED at Phase C v1: periodic-reminder, artifact-pool-ready,
+ * edge-artifact-required. The fourth POC policy (workflow-keepalive)
+ * ships in Phase D paired with workflow_instances; daemon registration
+ * MUST reject it with a structured deferred-to-phase-d error.
+ *
+ * State enum:
+ *   active   - scheduler is evaluating this job on its interval
+ *   stopped  - operator stopped the job; scheduler skips it
+ *   terminal - policy declared the job complete (e.g., workflow finished)
+ *
+ * Cadence columns mirror POC engine semantics:
+ *   - interval_seconds is the legacy / fallback cadence.
+ *   - scan_interval_seconds overrides the scheduler isDue cadence
+ *     (how often to run the policy at all).
+ *   - active_wake_interval_seconds throttles re-delivery: when the
+ *     pool stays continuously actionable, fire only every Nth scan.
+ *
+ * Active-wake state (R1 fix; POC parity for active-wake throttle):
+ *   - actionable: 1 iff the most recent scan returned action=send.
+ *     Used to detect newly-actionable transitions (no throttle on
+ *     transition; throttle on continued actionable state).
+ *   - last_actionable_at: first attempt time during the current
+ *     actionable window. Cleared when the policy returns skip.
+ *
+ * spec_yaml preserves the original operator-supplied YAML for audit.
+ */
+export declare const watchdogJobsSchema: Migration;
+//# sourceMappingURL=031_watchdog_jobs.d.ts.map

package/daemon/dist/db/migrations/031_watchdog_jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"031_watchdog_jobs.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/031_watchdog_jobs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,kBAAkB,EAAE,SA0BhC,CAAC"}

package/daemon/dist/db/migrations/031_watchdog_jobs.js

@@ -0,0 +1,59 @@
+/**
+ * Watchdog jobs (PL-004 Phase C; daemon-native Watchdog supervision tree).
+ *
+ * Per PRD § Watchdog + slice IMPL § Write Set: SQLite-canonical watchdog
+ * jobs that join the daemon supervision tree. Three policy enum values
+ * SHIPPED at Phase C v1: periodic-reminder, artifact-pool-ready,
+ * edge-artifact-required. The fourth POC policy (workflow-keepalive)
+ * ships in Phase D paired with workflow_instances; daemon registration
+ * MUST reject it with a structured deferred-to-phase-d error.
+ *
+ * State enum:
+ *   active   - scheduler is evaluating this job on its interval
+ *   stopped  - operator stopped the job; scheduler skips it
+ *   terminal - policy declared the job complete (e.g., workflow finished)
+ *
+ * Cadence columns mirror POC engine semantics:
+ *   - interval_seconds is the legacy / fallback cadence.
+ *   - scan_interval_seconds overrides the scheduler isDue cadence
+ *     (how often to run the policy at all).
+ *   - active_wake_interval_seconds throttles re-delivery: when the
+ *     pool stays continuously actionable, fire only every Nth scan.
+ *
+ * Active-wake state (R1 fix; POC parity for active-wake throttle):
+ *   - actionable: 1 iff the most recent scan returned action=send.
+ *     Used to detect newly-actionable transitions (no throttle on
+ *     transition; throttle on continued actionable state).
+ *   - last_actionable_at: first attempt time during the current
+ *     actionable window. Cleared when the policy returns skip.
+ *
+ * spec_yaml preserves the original operator-supplied YAML for audit.
+ */
+export const watchdogJobsSchema = {
+    name: "031_watchdog_jobs.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS watchdog_jobs (
+      job_id TEXT PRIMARY KEY,
+      policy TEXT NOT NULL,
+      spec_yaml TEXT NOT NULL,
+      target_session TEXT NOT NULL,
+      interval_seconds INTEGER NOT NULL,
+      active_wake_interval_seconds INTEGER,
+      scan_interval_seconds INTEGER,
+      last_evaluation_at TEXT,
+      last_fire_at TEXT,
+      actionable INTEGER NOT NULL DEFAULT 0,
+      last_actionable_at TEXT,
+      state TEXT NOT NULL DEFAULT 'active',
+      registered_by_session TEXT NOT NULL,
+      registered_at TEXT NOT NULL,
+      terminal_reason TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_watchdog_jobs_state ON watchdog_jobs(state);
+    CREATE INDEX IF NOT EXISTS idx_watchdog_jobs_policy ON watchdog_jobs(policy);
+    CREATE INDEX IF NOT EXISTS idx_watchdog_jobs_target_session ON watchdog_jobs(target_session);
+    CREATE INDEX IF NOT EXISTS idx_watchdog_jobs_active_next_eval
+      ON watchdog_jobs(last_evaluation_at) WHERE state = 'active';
+  `,
+};
+//# sourceMappingURL=031_watchdog_jobs.js.map

package/daemon/dist/db/migrations/031_watchdog_jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"031_watchdog_jobs.js","sourceRoot":"","sources":["../../../src/db/migrations/031_watchdog_jobs.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAc;IAC3C,IAAI,EAAE,uBAAuB;IAC7B,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;;GAuBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/032_watchdog_history.d.ts

@@ -0,0 +1,28 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Watchdog history (PL-004 Phase C; append-only audit log).
+ *
+ * Per PRD § Watchdog + slice IMPL § Guard Checkpoint Focus item 2:
+ * append-only history of meaningful watchdog events. Pure `not_due`
+ * polls are NOT recorded (matches POC; minimizes table size). Only
+ * `sent` (delivery executed), `skipped` (policy ran but skipped per
+ * its own logic — e.g., suppress_if_recent_success or
+ * no_actionable_artifacts), and `terminal` (policy declared job done)
+ * are recorded.
+ *
+ * Append-only contract: writers only INSERT. UPDATE/DELETE are not
+ * exposed by WatchdogHistoryLog API; direct SQL UPDATE/DELETE would
+ * succeed at the DB level (SQLite has no view/role layer) but is a
+ * contract violation enforced at the domain-layer API boundary.
+ *
+ * Outcome enum:
+ *   sent     - policy.evaluate() returned action=send and delivery executed
+ *   skipped  - policy.evaluate() returned action=skip (with reason)
+ *   terminal - policy.evaluate() returned action=terminal (job declared done)
+ *
+ * FK to watchdog_jobs(job_id) for referential integrity. Indexes on
+ * (job_id, evaluated_at DESC) for "recent history for one job" queries
+ * and (outcome, evaluated_at DESC) for cross-job outcome queries.
+ */
+export declare const watchdogHistorySchema: Migration;
+//# sourceMappingURL=032_watchdog_history.d.ts.map

package/daemon/dist/db/migrations/032_watchdog_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"032_watchdog_history.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/032_watchdog_history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAmBnC,CAAC"}

package/daemon/dist/db/migrations/032_watchdog_history.js

@@ -0,0 +1,46 @@
+/**
+ * Watchdog history (PL-004 Phase C; append-only audit log).
+ *
+ * Per PRD § Watchdog + slice IMPL § Guard Checkpoint Focus item 2:
+ * append-only history of meaningful watchdog events. Pure `not_due`
+ * polls are NOT recorded (matches POC; minimizes table size). Only
+ * `sent` (delivery executed), `skipped` (policy ran but skipped per
+ * its own logic — e.g., suppress_if_recent_success or
+ * no_actionable_artifacts), and `terminal` (policy declared job done)
+ * are recorded.
+ *
+ * Append-only contract: writers only INSERT. UPDATE/DELETE are not
+ * exposed by WatchdogHistoryLog API; direct SQL UPDATE/DELETE would
+ * succeed at the DB level (SQLite has no view/role layer) but is a
+ * contract violation enforced at the domain-layer API boundary.
+ *
+ * Outcome enum:
+ *   sent     - policy.evaluate() returned action=send and delivery executed
+ *   skipped  - policy.evaluate() returned action=skip (with reason)
+ *   terminal - policy.evaluate() returned action=terminal (job declared done)
+ *
+ * FK to watchdog_jobs(job_id) for referential integrity. Indexes on
+ * (job_id, evaluated_at DESC) for "recent history for one job" queries
+ * and (outcome, evaluated_at DESC) for cross-job outcome queries.
+ */
+export const watchdogHistorySchema = {
+    name: "032_watchdog_history.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS watchdog_history (
+      history_id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL REFERENCES watchdog_jobs(job_id),
+      evaluated_at TEXT NOT NULL,
+      outcome TEXT NOT NULL,
+      skip_reason TEXT,
+      delivery_target_session TEXT,
+      delivery_status TEXT,
+      delivery_message TEXT,
+      evaluation_notes TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_watchdog_history_job_recent
+      ON watchdog_history(job_id, evaluated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_watchdog_history_outcome_recent
+      ON watchdog_history(outcome, evaluated_at DESC);
+  `,
+};
+//# sourceMappingURL=032_watchdog_history.js.map

package/daemon/dist/db/migrations/032_watchdog_history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"032_watchdog_history.js","sourceRoot":"","sources":["../../../src/db/migrations/032_watchdog_history.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAc;IAC9C,IAAI,EAAE,0BAA0B;IAChC,GAAG,EAAE;;;;;;;;;;;;;;;;GAgBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/033_workflow_specs.d.ts

@@ -0,0 +1,30 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Workflow specs (PL-004 Phase D; daemon-native Workflow Runtime).
+ *
+ * Per PRD § L4 Workflow Runtime: workflow specs are markdown/YAML
+ * authoritative — the daemon caches a read-through copy here so that
+ * lookups are fast and instances can resolve the spec at runtime
+ * even if the source file moves. source_hash invalidates the cache
+ * on next read; valid operator edits to the spec file win
+ * (workspace-surface reconciliation contract).
+ *
+ * Columns:
+ *   - spec_id (ULID PK)
+ *   - name (workflow.id from spec yaml)
+ *   - version (workflow.version)
+ *   - purpose (workflow.objective)
+ *   - target_rig (workflow.target.rig)
+ *   - roles_json (serialized roles[] map)
+ *   - steps_json (serialized steps[] array)
+ *   - coordination_terminal_turn_rule (default `hot_potato`)
+ *   - source_path (markdown/yaml spec file path on disk)
+ *   - source_hash (content hash for invalidation detection)
+ *   - cached_at (ISO timestamp; latest read-through cache stamp)
+ *
+ * Unique constraint on (name, version) — a workflow spec at a given
+ * version is canonical; re-caching the same spec content updates
+ * cached_at + source_hash without inserting a duplicate row.
+ */
+export declare const workflowSpecsSchema: Migration;
+//# sourceMappingURL=033_workflow_specs.d.ts.map

package/daemon/dist/db/migrations/033_workflow_specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"033_workflow_specs.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/033_workflow_specs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAqBjC,CAAC"}

package/daemon/dist/db/migrations/033_workflow_specs.js

@@ -0,0 +1,50 @@
+/**
+ * Workflow specs (PL-004 Phase D; daemon-native Workflow Runtime).
+ *
+ * Per PRD § L4 Workflow Runtime: workflow specs are markdown/YAML
+ * authoritative — the daemon caches a read-through copy here so that
+ * lookups are fast and instances can resolve the spec at runtime
+ * even if the source file moves. source_hash invalidates the cache
+ * on next read; valid operator edits to the spec file win
+ * (workspace-surface reconciliation contract).
+ *
+ * Columns:
+ *   - spec_id (ULID PK)
+ *   - name (workflow.id from spec yaml)
+ *   - version (workflow.version)
+ *   - purpose (workflow.objective)
+ *   - target_rig (workflow.target.rig)
+ *   - roles_json (serialized roles[] map)
+ *   - steps_json (serialized steps[] array)
+ *   - coordination_terminal_turn_rule (default `hot_potato`)
+ *   - source_path (markdown/yaml spec file path on disk)
+ *   - source_hash (content hash for invalidation detection)
+ *   - cached_at (ISO timestamp; latest read-through cache stamp)
+ *
+ * Unique constraint on (name, version) — a workflow spec at a given
+ * version is canonical; re-caching the same spec content updates
+ * cached_at + source_hash without inserting a duplicate row.
+ */
+export const workflowSpecsSchema = {
+    name: "033_workflow_specs.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS workflow_specs (
+      spec_id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      version TEXT NOT NULL,
+      purpose TEXT,
+      target_rig TEXT,
+      roles_json TEXT NOT NULL,
+      steps_json TEXT NOT NULL,
+      coordination_terminal_turn_rule TEXT NOT NULL DEFAULT 'hot_potato',
+      source_path TEXT NOT NULL,
+      source_hash TEXT NOT NULL,
+      cached_at TEXT NOT NULL
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_specs_name_version
+      ON workflow_specs(name, version);
+    CREATE INDEX IF NOT EXISTS idx_workflow_specs_target_rig
+      ON workflow_specs(target_rig);
+  `,
+};
+//# sourceMappingURL=033_workflow_specs.js.map

package/daemon/dist/db/migrations/033_workflow_specs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"033_workflow_specs.js","sourceRoot":"","sources":["../../../src/db/migrations/033_workflow_specs.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAc;IAC5C,IAAI,EAAE,wBAAwB;IAC9B,GAAG,EAAE;;;;;;;;;;;;;;;;;;GAkBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/034_workflow_instances.d.ts

@@ -0,0 +1,42 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Workflow instances (PL-004 Phase D; live workflow state).
+ *
+ * Per PRD § L4 Workflow Runtime: a workflow instance is a SQLite-canonical
+ * record of a running workflow. Survives daemon restart without
+ * filesystem reconciliation. The current_frontier_json column holds the
+ * array of qitem_ids that are the active step packets at any given time.
+ *
+ * R2 fix (guard blocker 1): durable current-step binding via
+ * `current_step_id`. Replaces trail-based "last_step + 1" inference,
+ * which produced wrong results for reused-frontier packets (e.g.,
+ * waiting → resume on same packet would skip a step). Mirrors POC
+ * which extracts step_id from the current packet binding rather than
+ * inferring from trail order. v1 supports a single active frontier
+ * packet; multi-frontier (parallel branches) is graduation and would
+ * need a packet→step map.
+ *
+ * Status enum (matches POC + PRD):
+ *   - active: instance has at least one frontier packet in-flight
+ *   - waiting: instance has a frontier packet blocked on an external gate
+ *   - completed: terminal success state; current_frontier_json is []
+ *   - failed: terminal failure state
+ *
+ * fallback_synthesis: nullable text recording the agent-judgment
+ * synthesis used when peer continuity relay was not available (closed
+ * but no successor identified). Optional audit context.
+ *
+ * hop_count: count of step transitions executed; PRD invariant
+ * `loop_guards.max_hops` is checked at projection time.
+ *
+ * last_continuation_decision_json: optional structured record of the
+ * most recent continuation/closure decision (the `handoff_decision`,
+ * `wait_decision`, or `close_decision` shape from the POC). Used for
+ * trace and debugging.
+ *
+ * Indexes:
+ *   - (status, workflow_name) — fast "find active instances of workflow X"
+ *   - (created_by_session, status) — fast "find my live workflows"
+ */
+export declare const workflowInstancesSchema: Migration;
+//# sourceMappingURL=034_workflow_instances.d.ts.map

package/daemon/dist/db/migrations/034_workflow_instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"034_workflow_instances.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/034_workflow_instances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAsBrC,CAAC"}

package/daemon/dist/db/migrations/034_workflow_instances.js

@@ -0,0 +1,63 @@
+/**
+ * Workflow instances (PL-004 Phase D; live workflow state).
+ *
+ * Per PRD § L4 Workflow Runtime: a workflow instance is a SQLite-canonical
+ * record of a running workflow. Survives daemon restart without
+ * filesystem reconciliation. The current_frontier_json column holds the
+ * array of qitem_ids that are the active step packets at any given time.
+ *
+ * R2 fix (guard blocker 1): durable current-step binding via
+ * `current_step_id`. Replaces trail-based "last_step + 1" inference,
+ * which produced wrong results for reused-frontier packets (e.g.,
+ * waiting → resume on same packet would skip a step). Mirrors POC
+ * which extracts step_id from the current packet binding rather than
+ * inferring from trail order. v1 supports a single active frontier
+ * packet; multi-frontier (parallel branches) is graduation and would
+ * need a packet→step map.
+ *
+ * Status enum (matches POC + PRD):
+ *   - active: instance has at least one frontier packet in-flight
+ *   - waiting: instance has a frontier packet blocked on an external gate
+ *   - completed: terminal success state; current_frontier_json is []
+ *   - failed: terminal failure state
+ *
+ * fallback_synthesis: nullable text recording the agent-judgment
+ * synthesis used when peer continuity relay was not available (closed
+ * but no successor identified). Optional audit context.
+ *
+ * hop_count: count of step transitions executed; PRD invariant
+ * `loop_guards.max_hops` is checked at projection time.
+ *
+ * last_continuation_decision_json: optional structured record of the
+ * most recent continuation/closure decision (the `handoff_decision`,
+ * `wait_decision`, or `close_decision` shape from the POC). Used for
+ * trace and debugging.
+ *
+ * Indexes:
+ *   - (status, workflow_name) — fast "find active instances of workflow X"
+ *   - (created_by_session, status) — fast "find my live workflows"
+ */
+export const workflowInstancesSchema = {
+    name: "034_workflow_instances.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS workflow_instances (
+      instance_id TEXT PRIMARY KEY,
+      workflow_name TEXT NOT NULL,
+      workflow_version TEXT NOT NULL,
+      created_by_session TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      current_frontier_json TEXT NOT NULL DEFAULT '[]',
+      current_step_id TEXT,
+      hop_count INTEGER NOT NULL DEFAULT 0,
+      fallback_synthesis TEXT,
+      last_continuation_decision_json TEXT,
+      completed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_instances_status_name
+      ON workflow_instances(status, workflow_name);
+    CREATE INDEX IF NOT EXISTS idx_workflow_instances_creator_status
+      ON workflow_instances(created_by_session, status);
+  `,
+};
+//# sourceMappingURL=034_workflow_instances.js.map

package/daemon/dist/db/migrations/034_workflow_instances.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"034_workflow_instances.js","sourceRoot":"","sources":["../../../src/db/migrations/034_workflow_instances.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAc;IAChD,IAAI,EAAE,4BAA4B;IAClC,GAAG,EAAE;;;;;;;;;;;;;;;;;;;GAmBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/035_workflow_step_trails.d.ts

@@ -0,0 +1,29 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Workflow step trails (PL-004 Phase D; append-only history).
+ *
+ * Per PRD § L4 Workflow Runtime: every workflow step transition records
+ * a trail entry. Append-only: writers only INSERT. UPDATE/DELETE are
+ * not exposed by WorkflowStepTrailLog API; direct SQL would succeed
+ * (SQLite has no view/role layer) but is a contract violation enforced
+ * at the domain-layer API boundary.
+ *
+ * Columns:
+ *   - trail_id (ULID PK)
+ *   - instance_id (FK to workflow_instances)
+ *   - step_id (from spec; e.g., "produce", "review-convergence")
+ *   - step_role (from spec; e.g., "producer", "orchestrator")
+ *   - closed_at (ISO timestamp of the closure/transition)
+ *   - closure_reason (enum: "handoff", "waiting", "done", "failed")
+ *   - closure_evidence_json (operator-supplied evidence + system-derived
+ *     audit context; JSON-encoded)
+ *   - actor_session (the session that closed the packet — owner-as-author)
+ *   - next_qitem_id (FK to queue_items; null on terminal closure)
+ *   - prior_qitem_id (the closed packet; FK to queue_items)
+ *
+ * Indexes:
+ *   - (instance_id, closed_at DESC) — fast "trail for one workflow instance"
+ *   - (closed_at DESC) — global recent activity
+ */
+export declare const workflowStepTrailsSchema: Migration;
+//# sourceMappingURL=035_workflow_step_trails.d.ts.map

package/daemon/dist/db/migrations/035_workflow_step_trails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"035_workflow_step_trails.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/035_workflow_step_trails.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAoBtC,CAAC"}

package/daemon/dist/db/migrations/035_workflow_step_trails.js

@@ -0,0 +1,48 @@
+/**
+ * Workflow step trails (PL-004 Phase D; append-only history).
+ *
+ * Per PRD § L4 Workflow Runtime: every workflow step transition records
+ * a trail entry. Append-only: writers only INSERT. UPDATE/DELETE are
+ * not exposed by WorkflowStepTrailLog API; direct SQL would succeed
+ * (SQLite has no view/role layer) but is a contract violation enforced
+ * at the domain-layer API boundary.
+ *
+ * Columns:
+ *   - trail_id (ULID PK)
+ *   - instance_id (FK to workflow_instances)
+ *   - step_id (from spec; e.g., "produce", "review-convergence")
+ *   - step_role (from spec; e.g., "producer", "orchestrator")
+ *   - closed_at (ISO timestamp of the closure/transition)
+ *   - closure_reason (enum: "handoff", "waiting", "done", "failed")
+ *   - closure_evidence_json (operator-supplied evidence + system-derived
+ *     audit context; JSON-encoded)
+ *   - actor_session (the session that closed the packet — owner-as-author)
+ *   - next_qitem_id (FK to queue_items; null on terminal closure)
+ *   - prior_qitem_id (the closed packet; FK to queue_items)
+ *
+ * Indexes:
+ *   - (instance_id, closed_at DESC) — fast "trail for one workflow instance"
+ *   - (closed_at DESC) — global recent activity
+ */
+export const workflowStepTrailsSchema = {
+    name: "035_workflow_step_trails.sql",
+    sql: `
+    CREATE TABLE IF NOT EXISTS workflow_step_trails (
+      trail_id TEXT PRIMARY KEY,
+      instance_id TEXT NOT NULL REFERENCES workflow_instances(instance_id),
+      step_id TEXT NOT NULL,
+      step_role TEXT NOT NULL,
+      closed_at TEXT NOT NULL,
+      closure_reason TEXT NOT NULL,
+      closure_evidence_json TEXT,
+      actor_session TEXT NOT NULL,
+      next_qitem_id TEXT REFERENCES queue_items(qitem_id),
+      prior_qitem_id TEXT REFERENCES queue_items(qitem_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_step_trails_instance_recent
+      ON workflow_step_trails(instance_id, closed_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_workflow_step_trails_recent
+      ON workflow_step_trails(closed_at DESC);
+  `,
+};
+//# sourceMappingURL=035_workflow_step_trails.js.map

package/daemon/dist/db/migrations/035_workflow_step_trails.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"035_workflow_step_trails.js","sourceRoot":"","sources":["../../../src/db/migrations/035_workflow_step_trails.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAc;IACjD,IAAI,EAAE,8BAA8B;IACpC,GAAG,EAAE;;;;;;;;;;;;;;;;;GAiBJ;CACF,CAAC"}

package/daemon/dist/db/migrations/036_watchdog_policy_enum_extension.d.ts

@@ -0,0 +1,35 @@
+import type { Migration } from "../migrate.js";
+/**
+ * Watchdog policy enum extension (PL-004 Phase D).
+ *
+ * DOCUMENTING NO-OP MIGRATION.
+ *
+ * Phase C implements the watchdog_jobs.policy enum at the application
+ * layer (in WatchdogJobsRepository.register() via the PHASE_C_POLICIES
+ * array + WORKFLOW_KEEPALIVE_DEFERRED_POLICY constant). The SQLite
+ * column itself is plain TEXT with no CHECK constraint, so extending
+ * the enum to include "workflow-keepalive" requires NO schema change.
+ *
+ * The actual enforcement extension lives in:
+ *   packages/daemon/src/domain/watchdog-jobs-repository.ts
+ *     - PHASE_C_POLICIES → renamed to PHASE_D_POLICIES (or extended)
+ *       to include "workflow-keepalive"
+ *     - WORKFLOW_KEEPALIVE_DEFERRED_POLICY rejection removed
+ *
+ * This migration exists for two reasons:
+ *   1. Audit trail: documents that Phase D extended the policy enum
+ *      surface, even though no DDL was needed.
+ *   2. Migration sequence integrity: keeps Phase D's migration count
+ *      visible in the daemon startup log alongside the three new
+ *      workflow tables (033, 034, 035). Slice IMPL row 17 explicitly
+ *      requires the extension migration land "cleanly without
+ *      touching Phase C's existing migration files" — this no-op
+ *      satisfies that constraint.
+ *
+ * Per slice IMPL § Write Set:
+ *   "if the enforcement is application-layer in
+ *   `watchdog-policy-engine.ts`, the migration is a no-op SQL but
+ *   documents the policy enum intent."
+ */
+export declare const watchdogPolicyEnumExtensionSchema: Migration;
+//# sourceMappingURL=036_watchdog_policy_enum_extension.d.ts.map

package/daemon/dist/db/migrations/036_watchdog_policy_enum_extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"036_watchdog_policy_enum_extension.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/036_watchdog_policy_enum_extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,iCAAiC,EAAE,SAS/C,CAAC"}

package/daemon/dist/db/migrations/036_watchdog_policy_enum_extension.js

@@ -0,0 +1,43 @@
+/**
+ * Watchdog policy enum extension (PL-004 Phase D).
+ *
+ * DOCUMENTING NO-OP MIGRATION.
+ *
+ * Phase C implements the watchdog_jobs.policy enum at the application
+ * layer (in WatchdogJobsRepository.register() via the PHASE_C_POLICIES
+ * array + WORKFLOW_KEEPALIVE_DEFERRED_POLICY constant). The SQLite
+ * column itself is plain TEXT with no CHECK constraint, so extending
+ * the enum to include "workflow-keepalive" requires NO schema change.
+ *
+ * The actual enforcement extension lives in:
+ *   packages/daemon/src/domain/watchdog-jobs-repository.ts
+ *     - PHASE_C_POLICIES → renamed to PHASE_D_POLICIES (or extended)
+ *       to include "workflow-keepalive"
+ *     - WORKFLOW_KEEPALIVE_DEFERRED_POLICY rejection removed
+ *
+ * This migration exists for two reasons:
+ *   1. Audit trail: documents that Phase D extended the policy enum
+ *      surface, even though no DDL was needed.
+ *   2. Migration sequence integrity: keeps Phase D's migration count
+ *      visible in the daemon startup log alongside the three new
+ *      workflow tables (033, 034, 035). Slice IMPL row 17 explicitly
+ *      requires the extension migration land "cleanly without
+ *      touching Phase C's existing migration files" — this no-op
+ *      satisfies that constraint.
+ *
+ * Per slice IMPL § Write Set:
+ *   "if the enforcement is application-layer in
+ *   `watchdog-policy-engine.ts`, the migration is a no-op SQL but
+ *   documents the policy enum intent."
+ */
+export const watchdogPolicyEnumExtensionSchema = {
+    name: "036_watchdog_policy_enum_extension.sql",
+    sql: `
+    -- No DDL: Phase C policy enum is enforced at the application layer
+    -- via PHASE_D_POLICIES in watchdog-jobs-repository.ts. The
+    -- watchdog_jobs.policy column remains plain TEXT. This migration
+    -- exists as an audit-trail marker for the Phase D enum extension.
+    SELECT 1 WHERE 0;
+  `,
+};
+//# sourceMappingURL=036_watchdog_policy_enum_extension.js.map

package/daemon/dist/db/migrations/036_watchdog_policy_enum_extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"036_watchdog_policy_enum_extension.js","sourceRoot":"","sources":["../../../src/db/migrations/036_watchdog_policy_enum_extension.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAc;IAC1D,IAAI,EAAE,wCAAwC;IAC9C,GAAG,EAAE;;;;;;GAMJ;CACF,CAAC"}