akm-cli 0.9.1-beta.1 → 0.9.1-beta.2

package/dist/tasks/runner.js

@@ -49,12 +49,13 @@ import { resolveModel } from "../integrations/agent/model-aliases.js";
 import { executeRunner } from "../integrations/agent/runner-dispatch.js";
 import { chatCompletion } from "../llm/client.js";
 import { resolveAssetPath } from "../sources/resolve.js";
-import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, queryTaskHistory, reserveTaskHistoryAttempt, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
+import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, getTaskHistoryRuns, queryTaskHistory, reserveTaskHistoryAttempt, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
 import { runWorkflowSteps } from "../workflows/exec/run-workflow.js";
 import { findBareAkmExecutableIndex } from "./command-executable.js";
 import { collectTaskLogSensitiveValues } from "./log-redaction.js";
 import { parseTaskDocument } from "./parser.js";
 import { resolveAkmInvocation } from "./resolve-akm-bin.js";
+import { scheduledTaskContextEnv } from "./scheduler-invocation.js";
 import { validateTaskId } from "./task-id.js";
 export const INVALID_TASK_ATTEMPT_ID = "_invalid-task-id";
 export async function runTask(id, options) {
@@ -175,7 +176,8 @@ async function runCommandTask(input) {
         throw new Error("invariant: command target");
     const { cmd } = task.target;
     const spawnCmd = resolveNestedAkmCommand(cmd);
-    const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : null;
+    // Unset → the unattended default; `null` → the explicit no-timeout opt-out.
+    const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : DEFAULT_SCHEDULED_TASK_TIMEOUT_MS;
     const header = `[akm task] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
     const logLines = [header];
     const dbLines = [{ line: header }];
@@ -280,6 +282,18 @@ function resolveNestedAkmCommand(cmd) {
  * the explicit opt-out back to unbounded.
  */
 export const DEFAULT_WORKFLOW_TASK_TIMEOUT_MS = 6 * 60 * 60 * 1000;
+/**
+ * The same unattended default for command and prompt tasks.
+ *
+ * The reasoning above is about SCHEDULED runs, not about workflows: nobody is
+ * watching, and one wedged run silently stops the schedule. Command tasks
+ * defaulted to `null` (no kill timer) and prompt tasks inherited
+ * DEFAULT_AGENT_TIMEOUT_MS, also null — so a hung `curl`, a prompting agent
+ * waiting on stdin, or a stuck engine wedged the task forever while the
+ * workflow arm was protected. Same value, same opt-out: an explicit
+ * `timeoutMs:` wins, and `timeoutMs: null` restores unbounded.
+ */
+export const DEFAULT_SCHEDULED_TASK_TIMEOUT_MS = DEFAULT_WORKFLOW_TASK_TIMEOUT_MS;
 async function runWorkflowTask(input) {
     const { task, logPath, startedAt, now, runWorkflowStepsImpl, historyReserved } = input;
     if (task.target.kind !== "workflow")
@@ -310,6 +324,13 @@ async function runWorkflowTask(input) {
     // The prompt path logs the engine-fallback announcement; a workflow-backed
     // task must leave the same trace rather than silently using a chosen engine.
     let runWarnings = [];
+    // Stamp task-runner provenance for the duration of the run (DRIFT-6), as the
+    // command and prompt arms do. This arm executes IN-PROCESS, so the stamp goes
+    // on process.env — child akm invocations made by workflow steps inherit it.
+    // Without it, workflow-task traffic was recorded as user demand. A more
+    // specific stamp already present wins, matching the command arm.
+    const priorEventSource = process.env.AKM_EVENT_SOURCE;
+    process.env.AKM_EVENT_SOURCE = priorEventSource ?? "task";
     try {
         const execution = await runWorkflowStepsImpl({
             target: workflowTarget.ref,
@@ -331,6 +352,10 @@ async function runWorkflowTask(input) {
     }
     finally {
         deadline.disarm();
+        if (priorEventSource === undefined)
+            delete process.env.AKM_EVENT_SOURCE;
+        else
+            process.env.AKM_EVENT_SOURCE = priorEventSource;
     }
     // A timeout is a failed ATTEMPT even though the engine stopped cleanly: the
     // aborted run comes back `active` (resumable), which on its own would map to
@@ -483,7 +508,10 @@ async function runPromptTask(input) {
         runner = {
             ...runner,
             profile: { ...runner.profile, ...(model ? { model, modelIsExact: true } : {}) },
-            ...(promptTarget.timeoutMs !== undefined ? { timeoutMs: promptTarget.timeoutMs } : {}),
+            // Unset → the unattended default (DEFAULT_AGENT_TIMEOUT_MS is null, which
+            // let a prompting or wedged agent CLI hang the schedule); `null` → the
+            // explicit no-timeout opt-out.
+            timeoutMs: promptTarget.timeoutMs !== undefined ? promptTarget.timeoutMs : DEFAULT_SCHEDULED_TASK_TIMEOUT_MS,
         };
     }
     const promptText = await resolvePromptText(task, stashDir);
@@ -494,7 +522,13 @@ async function runPromptTask(input) {
         // Stamp task-runner provenance for any akm invocation the agent makes
         // (DRIFT-6: agent-task traffic must not be recorded as user demand).
         // Caller-supplied env still wins on conflicts.
-        env: { AKM_EVENT_SOURCE: "task", ...agentOptions?.env },
+        //
+        // The agent child env is built from an allowlist, not inherited, so the
+        // scheduler's AKM_* directory context was dropped here — an agent's `akm`
+        // sub-commands then targeted the DEFAULT stash and DB rather than the
+        // ones the scheduled run was configured for. The command arm keeps this
+        // context because it inherits process.env; forward it explicitly.
+        env: { AKM_EVENT_SOURCE: "task", ...scheduledTaskContextEnv(), ...agentOptions?.env },
     }, {
         ...(input.runAgentImpl ? { runAgent: input.runAgentImpl } : {}),
         llm: async (spec, prompt, options) => {
@@ -598,12 +632,49 @@ function resolveTaskLogPath(logDir, taskId, startedAtIso) {
         return "";
     }
 }
+/**
+ * Redact logs.db rows against the SAME contiguous text the file sink sees.
+ *
+ * The rows arrive already split on "\n" (see {@link streamLines}), but the
+ * redaction needles are whole env values — and a needle containing a newline
+ * can never match inside a single line. Scrubbing row-by-row therefore left
+ * multi-line secrets (PEM keys, multi-line service-account credentials) intact
+ * in logs.db while the flat .log was correctly scrubbed, defeating all three
+ * tiers including the explicit `redact:` opt-in.
+ *
+ * Consecutive rows sharing a stream and level are rejoined, scrubbed as one
+ * string, and re-split, so a needle spanning lines matches. Collapsing a
+ * multi-line secret into a single [REDACTED] row is the intended outcome.
+ */
+export function scrubDbLines(dbLines, scrub) {
+    const out = [];
+    for (let i = 0; i < dbLines.length;) {
+        const { stream, level } = dbLines[i];
+        let end = i;
+        while (end < dbLines.length && dbLines[end].stream === stream && dbLines[end].level === level)
+            end++;
+        const joined = dbLines
+            .slice(i, end)
+            .map((entry) => entry.line)
+            .join("\n");
+        for (const line of scrub(joined).split("\n")) {
+            if (line.length > 0)
+                out.push({ stream, level, line });
+        }
+        i = end;
+    }
+    return out;
+}
 /** Split captured pipe output into per-line logs.db rows (blank lines dropped). */
 function streamLines(text, stream, level) {
-    return text
+    return (text
         .split("\n")
+        // Windows child output is CRLF-terminated. Splitting on "\n" alone left a
+        // trailing "\r" on every row and turned blank CRLF lines into phantom
+        // rows containing just "\r" (length 1 passes the filter below).
+        .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line))
         .filter((line) => line.length > 0)
-        .map((line) => ({ stream, level, line }));
+        .map((line) => ({ stream, level, line })));
 }
 /**
  * Persist a finished run's log: the flat text file (so `log_path` in
@@ -661,7 +732,7 @@ function persistRunLog(input) {
         ? redactSensitiveText(redactCredentialPatterns(text), sensitive)
         : redactCredentialPatterns(text);
     const fileText = scrub(input.fileText);
-    const dbLines = input.dbLines.map((entry) => ({ ...entry, line: scrub(entry.line) }));
+    const dbLines = scrubDbLines(input.dbLines, scrub);
     if (input.logPath) {
         try {
             // Written at the process umask. #756 pinned 0600/0700 here; that went out
@@ -820,6 +891,12 @@ export function readTaskHistory(options = {}) {
         if (options.limit === 0)
             return [];
         if (options.id) {
+            // An id-scoped query used the single-row helper, so `--limit` was silently
+            // discarded and `akm task history --id X --limit 20` always returned one
+            // run. The CLI documents --limit as "Maximum rows to return"; honour it.
+            if (options.limit !== undefined && options.limit > 0) {
+                return getTaskHistoryRuns(db, options.id, options.limit).map(taskHistoryRowToResult);
+            }
             const row = getTaskHistory(db, options.id);
             return row ? [taskHistoryRowToResult(row)] : [];
         }

package/dist/tasks/scheduler-invocation.js

@@ -14,6 +14,25 @@ export const SCHEDULED_TASK_CONTEXT_KEYS = [
     "AKM_CACHE_DIR",
     "AKM_STATE_DIR",
 ];
+/**
+ * The AKM_* directory context currently in effect, as a plain env fragment.
+ *
+ * A scheduled run restores these into `process.env` from its
+ * `--scheduler-context` descriptor precisely because such installs have
+ * non-default directories. Paths that build a child environment from an
+ * allowlist rather than inheriting (the agent spawn) must forward this
+ * explicitly, or the child's `akm` sub-commands silently target the default
+ * stash and DB.
+ */
+export function scheduledTaskContextEnv(env = process.env) {
+    const out = {};
+    for (const key of SCHEDULED_TASK_CONTEXT_KEYS) {
+        const value = env[key];
+        if (value)
+            out[key] = value;
+    }
+    return out;
+}
 export const SCHEDULER_CONTEXT_ARG = "--scheduler-context";
 /** Resolve the complete non-secret AKM directory context captured by schedulers. */
 export function resolveScheduledTaskContext(env = process.env, platform = process.platform) {

package/dist/tasks/schema.js

@@ -52,8 +52,28 @@ export const TASK_MAX_REDACT_NAMES = WORKFLOW_MAX_EXEC_PASS_ENV;
  * at runtime with TASK_SCHEMA_VERSION_UNSUPPORTED). `schemas/akm-task.json`
  * agrees with the parser: `required: [version, schedule]`, `version:
  * {const: 2}`, `enabled` optional but boolean. Target-arity rules stay with
- * each caller (they legitimately differ: at-least-one vs exactly-one).
+ * each caller (they legitimately differ: at-least-one vs exactly-one), but
+ * what COUNTS as a target is shared — see {@link isPresentTarget}.
  */
+/**
+ * Whether a task-target field counts as declared.
+ *
+ * The arity rules differ between the two linters, but the presence test must
+ * not: the runtime parser treats `""` as absent, so a key-existence check let
+ * `workflow: ""` lint clean and then die with MISSING_REQUIRED_ARGUMENT. An
+ * array target (`command`) counts only when it has entries, for the same
+ * reason. Kept beside {@link taskFieldProblems} so all three definitions of
+ * "valid task" stay in one file.
+ */
+export function isPresentTarget(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === "string")
+        return value.trim() !== "";
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
 export function taskFieldProblems(data) {
     const problems = [];
     if (data.version !== TASK_SCHEMA_VERSION)

package/dist/text-import-hook.mjs

@@ -16,7 +16,7 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
-const TEXT_EXTENSIONS = new Set([".md", ".xml", ".txt", ".sql", ".yaml", ".yml"]);
+const TEXT_EXTENSIONS = new Set([".md", ".xml", ".txt", ".sql", ".yaml", ".yml", ".html"]);
 
 function isTextImport(url, importAttributes) {
   if (importAttributes && importAttributes.type === "text") return true;

package/dist/workflows/exec/native-executor.js

@@ -948,6 +948,14 @@ async function dispatchUnit(request, dispatcher) {
             return {
                 unitId: request.unitId,
                 ok: false,
+                // NOTE: `validation_error` is deliberately outside PROGRAM_RETRY_REASONS,
+                // so no `retry.on:` can name it and a schema-violating unit is not
+                // re-run — see "fails with `validation_error` and is NOT re-run" in
+                // tests/integration/workflows/exec-unit.test.ts. A sweep finding
+                // proposed mapping it onto `llm_invalid_json` (which the parser accepts
+                // but this path never emits) to make such failures retryable; that is a
+                // behaviour change against an intentional design, not a bug fix, so it
+                // is left alone. Reconciling the vocabulary is a 0.9.2 decision.
                 failureReason: structured.reason,
                 error: structured.errors.join("; "),
                 text: structured.raw,

package/dist/workflows/exec/step-work.js

@@ -667,8 +667,16 @@ export function buildEvidence(units, reducer, isFanOut) {
             evidence.voteError = `Vote reducer tied at ${ranked[0].count} vote(s) — no majority.`;
         }
         else {
-            evidence.vote = { winner: ranked[0].value, votes: ranked[0].count, total: units.length };
-            evidence.output = ranked[0].value;
+            const winner = ranked[0].value;
+            evidence.vote = { winner, votes: ranked[0].count, total: units.length };
+            // An empty free-text unit normalizes to absent text, so its vote value is
+            // `undefined`. Assigning that to `evidence.output` made the key vanish
+            // under JSON serialization: a LIVE run then saw `output` absent (and fell
+            // back to the whole evidence envelope), while a RESUMED run rehydrated the
+            // same step from the journal and produced a different artifact — with the
+            // raw envelope exposed as `steps.<id>.output`. Normalize to an explicit
+            // empty string so both paths promote the same value.
+            evidence.output = winner === undefined ? "" : winner;
         }
     }
     return evidence;

package/dist/workflows/parser.js

@@ -655,7 +655,16 @@ function parseUnit(ctx, raw, path, stepLabel) {
         unit.output = output;
     if (raw.env !== undefined) {
         if (Array.isArray(raw.env) && raw.env.every((entry) => typeof entry === "string" && entry.trim() !== "")) {
-            unit.env = raw.env.map((entry) => entry.trim());
+            const envRefs = raw.env.map((entry) => entry.trim());
+            // Same decoder uniqueness requirement as `inputs` above: duplicates linted
+            // clean and then failed the run with an unlocated frozen-plan error.
+            const duplicate = envRefs.find((ref, i) => envRefs.indexOf(ref) !== i);
+            if (duplicate !== undefined) {
+                ctx.err([...path, "env"], `${stepLabel} "env" contains a duplicate entry: "${duplicate}".`);
+            }
+            else {
+                unit.env = envRefs;
+            }
         }
         else {
             ctx.err([...path, "env"], `${stepLabel} "env" must be a list of non-empty env asset refs.`);
@@ -859,6 +868,13 @@ function parseRoute(ctx, raw, path, stepLabel, stepIndex, routeChecks) {
                 return;
             }
             const match = String(branch.match);
+            // The frozen-plan decoder requires every `when` key to be non-empty, so an
+            // empty match parsed and linted clean and then failed the run with an
+            // unlocated "Invalid frozen workflow plan". Reject it here, at the line.
+            if (match === "") {
+                ctx.errAtLine(matchLine, `${stepLabel} "when[${i}].match" must not be empty.`);
+                return;
+            }
             if (typeof branch.step !== "string" || branch.step.trim() === "") {
                 ctx.err([...branchPath, "step"], `${stepLabel} "when[${i}].step" must be a step id string.`);
                 return;
@@ -901,12 +917,21 @@ function parseInputs(ctx, raw, path, stepLabel) {
         ctx.err(path, `${stepLabel} "inputs" must contain at most ${WORKFLOW_MAX_INPUTS} entries.`);
     }
     const out = [];
+    // The frozen-plan decoder requires uniqueness (validateStringArray(..., true)),
+    // so duplicates parsed and linted clean and then failed the run with an
+    // unlocated "Invalid frozen workflow plan". Reject them here, on the entry.
+    const seen = new Set();
     raw.forEach((entry, i) => {
         if (typeof entry !== "string" || entry.trim() === "") {
             ctx.err([...path, i], `${stepLabel} "inputs[${i}]" must be a non-empty reference string.`);
             return;
         }
         const value = entry.trim();
+        if (seen.has(value)) {
+            ctx.err([...path, i], `${stepLabel} "inputs[${i}]" duplicates an earlier entry: "${value}".`);
+            return;
+        }
+        seen.add(value);
         checkReferenceSyntax(ctx, value, [...path, i], `${stepLabel} "inputs[${i}]"`);
         out.push(value);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.1-beta.1",
+  "version": "0.9.1-beta.2",
   "type": "module",
   "description": "akm (Agent Knowledge Manager) — a portable, local-first capability library for AI agents. Discover, load, share, and improve reusable skills, scripts, workflows, and knowledge across any shell-capable coding agent, including Claude Code, OpenCode, and Cursor.",
   "keywords": [

package/schemas/akm-config.json

@@ -45,7 +45,8 @@
                 "anyOf": [
                   {
                     "type": "integer",
-                    "exclusiveMinimum": 0
+                    "exclusiveMinimum": 0,
+                    "maximum": 2147483647
                   },
                   {
                     "type": "null"
@@ -122,7 +123,8 @@
                 "anyOf": [
                   {
                     "type": "integer",
-                    "exclusiveMinimum": 0
+                    "exclusiveMinimum": 0,
+                    "maximum": 2147483647
                   },
                   {
                     "type": "null"
@@ -1697,7 +1699,8 @@
                     "anyOf": [
                       {
                         "type": "integer",
-                        "exclusiveMinimum": 0
+                        "exclusiveMinimum": 0,
+                        "maximum": 2147483647
                       },
                       {
                         "type": "null"
@@ -1774,7 +1777,8 @@
                     "anyOf": [
                       {
                         "type": "integer",
-                        "exclusiveMinimum": 0
+                        "exclusiveMinimum": 0,
+                        "maximum": 2147483647
                       },
                       {
                         "type": "null"
@@ -3332,7 +3336,8 @@
           "anyOf": [
             {
               "type": "integer",
-              "exclusiveMinimum": 0
+              "exclusiveMinimum": 0,
+              "maximum": 2147483647
             },
             {
               "type": "null"

package/schemas/akm-workflow.json

@@ -309,11 +309,12 @@
         },
         "env": {
           "type": "array",
+          "uniqueItems": true,
           "items": {
             "type": "string",
             "minLength": 1
           },
-          "description": "Env asset refs injected into the dispatched unit env."
+          "description": "Env asset refs injected into the dispatched unit env. Entries must be unique: the frozen-plan decoder rejects duplicates at run start."
         },
         "isolation": {
           "$ref": "#/definitions/isolation"
@@ -350,7 +351,9 @@
       "additionalProperties": false,
       "properties": {
         "match": {
-          "type": ["string", "number", "boolean"]
+          "type": ["string", "number", "boolean"],
+          "minLength": 1,
+          "description": "Branch key. An empty string is rejected: the frozen-plan decoder requires every `when` key to be non-empty."
         },
         "step": {
           "$ref": "#/definitions/identifier"
@@ -397,10 +400,11 @@
       "type": "array",
       "minItems": 1,
       "maxItems": 64,
+      "uniqueItems": true,
       "items": {
         "$ref": "#/definitions/reference"
       },
-      "description": "Prior-step artifacts this unit/map step consumes, as reference strings (sub-paths legal). Attached to the dispatched unit as structured context; never spliced into instructions."
+      "description": "Prior-step artifacts this unit/map step consumes, as reference strings (sub-paths legal). Attached to the dispatched unit as structured context; never spliced into instructions. Entries must be unique: the frozen-plan decoder rejects duplicates at run start."
     },
     "step": {
       "type": "object",