taskforce-loop-engineering 0.8.3 → 0.8.5

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.8.5 - 2026-08-08
+
+- Fixed generated systemd scheduler units so `WorkingDirectory` and `ExecStart` use unquoted, byte-safe systemd path escapes.
+- Added real `systemd-analyze verify` coverage for scheduler paths containing spaces and non-ASCII characters.
+
+## 0.8.4 - 2026-08-07
+
+- Reclaim queue locks immediately when their recorded owner PID no longer
+  exists, even if the lease has not expired. Scheduler status no longer reports
+  those dead-owner locks as live, and an orphaned `active/` task forces recovery
+  on the next timer wake-up instead of waiting for scheduler backoff or lease
+  expiry.
+
+- Distinguish one-time secret human inputs from durable non-sensitive decisions
+  and attestations, so review approvals remain available as structured evidence
+  while OTPs, passwords, tokens, and credential values are still destroyed after
+  consumption.
+- Restrict human-gate reconciliation to the final judgement's effective
+  checkpoint set for every outcome, preventing a project-in-progress tick from
+  resurrecting historical waiting gates after a newer checkpoint clears them.
+- Allow an explicitly superseded human gate to requeue a task from `waiting/`
+  through the normal queue CLI instead of requiring a manual file move.
+
 ## 0.8.3 - 2026-08-07
 
 - Select the latest single-milestone checkpoint by durable checkpoint identity/sequence instead of regenerated acceptance-review timestamps, preventing a lexically late legacy `cp9` review from overriding a blocked `cp46+` checkpoint.

package/README.md

@@ -370,6 +370,11 @@ loop-engineering queue-human-input-resolve \
 The human-input notifier scans active and terminal tasks, sends the concrete
 checkpoint blocker, and records a `waiting_for_human` gate. Resolution is
 idempotent; a terminal blocked task is requeued with the response attached.
+OTP, password, token, credential, and verification-code gates are inferred as
+one-time secrets and destroyed after consumption. Review decisions, approvals,
+assignments, and attestations remain available in the gate event as durable
+non-sensitive evidence. Use `--secret-input` or `--non-secret-input` to override
+the inference when gate wording is ambiguous.
 
 Goal-directed controllers can use the exported `normalizeGoalDecision`,
 `goalLoopTransition`, and `goalStrategyFingerprint` helpers. They distinguish

package/bin/loop-engineering.mjs

@@ -154,6 +154,8 @@ function parseArgs(argv) {
     else if (a === '--notify-command') args.notifyCommand = argv[++i];
     else if (a === '--gate-id') args.gateId = argv[++i];
     else if (a === '--input') args.input = argv[++i];
+    else if (a === '--secret-input') args.secretInput = true;
+    else if (a === '--non-secret-input') args.nonSecretInput = true;
     else if (a === '--source-channel') args.sourceChannel = argv[++i];
     else if (a === '--source-target') args.sourceTarget = argv[++i];
     else if (a === '--source-account') args.sourceAccount = argv[++i];
@@ -2077,7 +2079,7 @@ async function queueRequeueCommand(args) {
   if (!args.taskId) throw new Error('queue-requeue requires --task-id.');
   const config = await loadQueueConfig(args.root, args.config);
   const options = mergeQueueOptions(config, args);
-  const result = await queueRequeue(args.root, options.queue, args.taskId);
+  const result = await queueRequeue(args.root, options.queue, args.taskId, { from: args.from });
   if (args.json) console.log(JSON.stringify(result, null, 2));
   else console.log(`requeued ${result.taskId}: ${result.file}`);
   return 0;

package/lib/core.mjs

@@ -1826,7 +1826,7 @@ export async function notifyHumanInputRequests(root, options = {}) {
     const judgementFile = path.join(taskRuntimeDirFor(root, queue, taskId), 'final_judgement.json');
     if (await exists(judgementFile)) {
       const judgement = await readJson(judgementFile);
-      const effectiveIds = judgement?.outcome === 'blocked' && Array.isArray(judgement?.coverage?.effective_review_ids)
+      const effectiveIds = Array.isArray(judgement?.coverage?.effective_review_ids)
         ? new Set(judgement.coverage.effective_review_ids)
         : null;
       if (effectiveIds?.size > 0) {
@@ -1932,28 +1932,40 @@ export async function resolveHumanInput(root, options = {}) {
   if (['resolved', 'consumed', 'satisfied'].includes(gate.status)) return { gate, outcome: 'already_resolved', ledger: path.relative(root, ledgerFile) };
   const receivedAt = new Date().toISOString();
   const response = options.input.trim();
+  const requestText = `${gate.request ?? ''}\n${JSON.stringify(gate.needed ?? '')}`.toLowerCase();
+  const inferredSecret = /(?:otp|one[- ]time|verification code|sms code|验证码|校验码|口令|password|api[ _-]?key|access[ _-]?token|secret|credential value|密钥|令牌)/i.test(requestText);
+  const inputKind = options.secretInput === true
+    ? 'secret'
+    : options.nonSecretInput === true
+      ? 'attestation'
+      : inferredSecret ? 'secret' : 'attestation';
+  const secretReceived = inputKind === 'secret';
   const secretDir = path.join(queueDirFor(root, queue), 'human-input', 'secrets');
   const eventsDir = path.join(queueDirFor(root, queue), 'human-input', 'events');
-  await mkdir(secretDir, { recursive: true, mode: 0o700 });
   await mkdir(eventsDir, { recursive: true });
-  const secretFile = path.join(secretDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.secret`);
-  const handle = await open(secretFile, 'wx', 0o600);
-  try {
-    await handle.writeFile(response);
-  } finally {
-    await handle.close();
+  let secretFile = null;
+  if (secretReceived) {
+    await mkdir(secretDir, { recursive: true, mode: 0o700 });
+    secretFile = path.join(secretDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.secret`);
+    const handle = await open(secretFile, 'wx', 0o600);
+    try {
+      await handle.writeFile(response);
+    } finally {
+      await handle.close();
+    }
   }
   const responseSha256 = createHash('sha256').update(response).digest('hex');
   const resolved = {
     ...gate,
     status: 'resolved',
-    secret_received: true,
+    input_kind: inputKind,
+    secret_received: secretReceived,
     response_sha256: responseSha256,
-    response_ref: path.relative(root, secretFile),
+    ...(secretReceived ? { response_ref: path.relative(root, secretFile) } : { response }),
     response_message_id: options.sourceMessageId ?? null,
     resolved_at: receivedAt
   };
-  delete resolved.response;
+  if (secretReceived) delete resolved.response;
   await writeJson(ledgerFile, resolved);
   const eventFile = path.join(eventsDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.json`);
   await writeJson(eventFile, {
@@ -1963,9 +1975,10 @@ export async function resolveHumanInput(root, options = {}) {
     task_id: taskId,
     checkpoint_id: checkpointId,
     status: 'pending_consumption',
-    secret_received: true,
+    input_kind: inputKind,
+    secret_received: secretReceived,
     response_sha256: responseSha256,
-    response_ref: path.relative(root, secretFile),
+    ...(secretReceived ? { response_ref: path.relative(root, secretFile) } : { response }),
     response_message_id: options.sourceMessageId ?? null,
     created_at: receivedAt
   });
@@ -1979,7 +1992,8 @@ export async function resolveHumanInput(root, options = {}) {
       humanInput: {
         gate_id: options.gateId,
         checkpoint_id: checkpointId,
-        secret_received: true,
+        input_kind: inputKind,
+        secret_received: secretReceived,
         response_sha256: responseSha256,
         event: path.relative(root, eventFile),
         received_at: receivedAt
@@ -2030,8 +2044,10 @@ async function prepareHumanInputContext(root, queue, taskId) {
       checkpoint_id: consumed.checkpoint_id,
       status: consumed.status,
       secret_received: Boolean(consumed.secret_received),
+      input_kind: consumed.input_kind ?? (consumed.secret_received ? 'secret' : 'attestation'),
       response_sha256: consumed.response_sha256 ?? null,
       response_ref: consumed.response_ref ? path.join(root, consumed.response_ref) : null,
+      response: consumed.secret_received ? null : consumed.response ?? null,
       resolved_at: consumed.resolved_at ?? null,
       consumed_at: consumed.consumed_at ?? null
     });
@@ -3191,6 +3207,7 @@ export async function queueStatus(root, queue) {
   await ensureQueueDirs(root, queue);
   const activeFiles = await listJson(queueSubdirFor(root, queue, 'active'));
   const lock = await readQueueLock(root, queue);
+  const lockOwnerAlive = queueLockOwnerAlive(lock);
   return {
     queue,
     queued: (await listJson(queueSubdirFor(root, queue, 'inbox'))).length,
@@ -3200,8 +3217,10 @@ export async function queueStatus(root, queue) {
     failed: (await listJson(queueSubdirFor(root, queue, 'failed'))).length,
     canceled: (await listJson(queueSubdirFor(root, queue, 'canceled'))).length,
     runs: (await listJson(queueSubdirFor(root, queue, 'runs'))).length,
-    locked: Boolean(lock && Date.parse(lock.expiresAt) > Date.now()),
-    lockExpiresAt: lock?.expiresAt ?? null
+    locked: Boolean(lock && Date.parse(lock.expiresAt) > Date.now() && lockOwnerAlive),
+    lockExpiresAt: lock?.expiresAt ?? null,
+    lockPid: lock?.pid ?? null,
+    lockOwnerAlive
   };
 }
 
@@ -3509,7 +3528,13 @@ export async function queueSchedulerTick(root, options) {
   const previous = await readQueueSchedulerState(root, queue);
   const previousProgress = await readQueueProgressState(root, queue);
   const statusBefore = await queueStatus(root, queue);
-  const due = !previous?.nextRunAt || Date.parse(previous.nextRunAt) <= nowMs || Boolean(options.forceDue);
+  // An active task without a live lock owner is an orphan. Do not let a
+  // previously scheduled backoff postpone recovery until nextRunAt.
+  const orphanedActive = statusBefore.active > 0 && !statusBefore.locked;
+  const due = orphanedActive
+    || !previous?.nextRunAt
+    || Date.parse(previous.nextRunAt) <= nowMs
+    || Boolean(options.forceDue);
   let runResult = null;
   let executed = false;
   let status = due ? 'due' : 'not_due';
@@ -3768,11 +3793,27 @@ async function readQueueLock(root, queue) {
   }
 }
 
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM means the process exists but this user cannot signal it.
+    return Boolean(err && err.code === 'EPERM');
+  }
+}
+
+function queueLockOwnerAlive(lock) {
+  return Boolean(lock && processIsAlive(lock.pid));
+}
+
 async function acquireQueueLock(root, queue, leaseMs) {
   const lockFile = path.join(queueDirFor(root, queue), 'queue.lock');
   const now = Date.now();
   const existing = await readQueueLock(root, queue);
-  if (existing && Date.parse(existing.expiresAt) > now) {
+  const existingOwnerAlive = queueLockOwnerAlive(existing);
+  if (existing && Date.parse(existing.expiresAt) > now && existingOwnerAlive) {
     return { acquired: false, lock: existing };
   }
   if (existing) await rm(lockFile, { force: true });
@@ -3787,7 +3828,14 @@ async function acquireQueueLock(root, queue, leaseMs) {
   try {
     handle = await open(lockFile, 'wx');
     await handle.writeFile(`${JSON.stringify(lock, null, 2)}\n`);
-    return { acquired: true, lock };
+    return {
+      acquired: true,
+      lock,
+      reclaimedLock: existing ? {
+        lock: existing,
+        reason: existingOwnerAlive ? 'expired_lease' : 'dead_owner_pid'
+      } : null
+    };
   } catch (err) {
     if (err && err.code === 'EEXIST') {
       return { acquired: false, lock: await readQueueLock(root, queue) };
@@ -3863,7 +3911,9 @@ export async function queueCancel(root, queue, taskId, options = {}) {
 export async function queueRequeue(root, queue, taskId, options = {}) {
   const normalized = normalizeLoopId(queue);
   await ensureQueueDirs(root, normalized);
-  const found = await findTaskFile(root, normalized, taskId, options.from ? [options.from] : ['failed', 'active', 'canceled']);
+  const allowedSources = ['failed', 'active', 'waiting', 'canceled'];
+  if (options.from && !allowedSources.includes(options.from)) throw new Error(`Unsupported requeue source: ${options.from}`);
+  const found = await findTaskFile(root, normalized, taskId, options.from ? [options.from] : allowedSources);
   if (!found) throw new Error(`Task not found in requeueable state: ${taskId}`);
   const task = await readJson(found.file);
   const inboxFile = path.join(queueSubdirFor(root, normalized, 'inbox'), path.basename(found.file));
@@ -7774,7 +7824,7 @@ async function recoverStaleActive(root, queue, staleActiveMs) {
   return recovered;
 }
 
-async function recoverOrphanActive(root, queue) {
+async function recoverOrphanActive(root, queue, recoveryReason = 'queue_lock_reacquired_with_active_task') {
   const activeDir = queueSubdirFor(root, queue, 'active');
   const inboxDir = queueSubdirFor(root, queue, 'inbox');
   const files = await listJson(activeDir);
@@ -7793,7 +7843,7 @@ async function recoverOrphanActive(root, queue) {
       orphanRecoveryCount: (task.orphanRecoveryCount ?? 0) + 1,
       requeuedAt: recoveredAt,
       requeuedFrom: 'active',
-      recoveryReason: 'queue_lock_reacquired_with_active_task'
+      recoveryReason
     });
     recovered.push({
       taskId: task.id,
@@ -8193,7 +8243,10 @@ export async function runQueueOnce(root, options) {
     // queue lease. Any task left in active/ is therefore an orphan from an
     // interrupted parent runner. Requeue it immediately so existing
     // checkpoints can be reviewed and execution can resume in this tick.
-    const orphanRecovered = await recoverOrphanActive(root, queue);
+    const recoveryReason = lockResult.reclaimedLock?.reason === 'dead_owner_pid'
+      ? 'dead_queue_lock_owner_pid'
+      : 'queue_lock_reacquired_with_active_task';
+    const orphanRecovered = await recoverOrphanActive(root, queue, recoveryReason);
     if (orphanRecovered.length > 0) {
       progress.emit('queue', 'orphan_recovered', `Recovered ${orphanRecovered.length} orphan active task(s)`, {
         queue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",

package/scripts/openclaw-install-self-test.mjs

@@ -4,7 +4,7 @@ import { spawn } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 
-const root = await mkdtemp(path.join(tmpdir(), 'loop-openclaw-install-'));
+const root = await mkdtemp(path.join(tmpdir(), 'loop openclaw 安装-'));
 const deliveryCapture = path.join(root, 'delivery.json');
 const mockOpenClaw = path.join(root, 'mock-openclaw.mjs');
 const mockSystemctl = path.join(root, 'mock-systemctl.mjs');
@@ -66,6 +66,14 @@ const timerFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/openclaw-
 const service = await readFile(serviceFile, 'utf8');
 const timer = await readFile(timerFile, 'utf8');
 if (!service.includes('scheduler-tick') || !timer.includes('OnUnitActiveSec=1min')) throw new Error('scheduler systemd units were not installed');
+if (service.includes('WorkingDirectory="') || service.includes('ExecStart="') || !service.includes('\\x20') || !service.includes('\\xe5\\xae\\x89\\xe8\\xa3\\x85')) throw new Error('scheduler service paths were not encoded with systemd path escapes');
+const systemdVerify = await new Promise((resolve) => {
+  const child = spawn('systemd-analyze', ['verify', serviceFile, timerFile], { stdio: ['ignore', 'pipe', 'pipe'] });
+  let stdout = ''; let stderr = ''; child.stdout.on('data', (chunk) => { stdout += chunk; }); child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.on('error', (error) => resolve({ code: 127, stdout, stderr: `${stderr}${error.message}` }));
+  child.on('close', (code) => resolve({ code, stdout, stderr }));
+});
+if (systemdVerify.code !== 0) throw new Error(`systemd rejected generated scheduler units: ${systemdVerify.stderr || systemdVerify.stdout}`);
 const installSystemctlCalls = await readFile(systemctlCapture, 'utf8');
 if (!installSystemctlCalls.includes('["--user","enable","--now","openclaw-loop-test-tasks-scheduler.timer"]')) throw new Error('scheduler timer was not enabled');
 const schedulerTick = await new Promise((resolve) => {

package/scripts/openclaw-install.mjs

@@ -22,8 +22,12 @@ function parseArgs(argv) {
   return out;
 }
 
-function systemdEscape(value) {
-  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+function systemdEscapePath(value) {
+  return [...Buffer.from(String(value))]
+    .map((byte) => /[A-Za-z0-9/_.:-]/.test(String.fromCharCode(byte))
+      ? String.fromCharCode(byte)
+      : `\\x${byte.toString(16).padStart(2, '0')}`)
+    .join('');
 }
 
 function safeId(value, label) {
@@ -140,7 +144,7 @@ if (command === 'route') {
 }
 
 function schedulerServiceSource({ root, queue }) {
-  return `[Unit]\nDescription=Taskforce Loop Engineering scheduler for ${queue}\nAfter=default.target\n\n[Service]\nType=oneshot\nWorkingDirectory="${systemdEscape(root)}"\nExecStart="${systemdEscape(process.execPath)}" "${systemdEscape(path.join(root, 'scripts', 'loops', 'openclaw-loop.mjs'))}" scheduler-tick --json\n`;
+  return `[Unit]\nDescription=Taskforce Loop Engineering scheduler for ${queue}\nAfter=default.target\n\n[Service]\nType=oneshot\nWorkingDirectory=${systemdEscapePath(root)}\nExecStart=${systemdEscapePath(process.execPath)} ${systemdEscapePath(path.join(root, 'scripts', 'loops', 'openclaw-loop.mjs'))} scheduler-tick --json\n`;
 }
 
 function schedulerTimerSource({ queue }) {

package/scripts/route-notify-self-test.mjs

@@ -11,6 +11,7 @@ import {
   notifyHumanInputRequests,
   notifyTerminalTasks,
   queueHumanDecision,
+  queueDirFor,
   queueStatus,
   queueSubdirFor,
   readJson,
@@ -92,6 +93,14 @@ const orphanInbox = path.join(queueSubdirFor(root, orphanQueue, 'inbox'), orphan
 const orphanActive = path.join(queueSubdirFor(root, orphanQueue, 'active'), orphanName);
 await writeJson(orphanActive, { ...(await readJson(orphanInbox)), status: 'active', startedAt: new Date().toISOString() });
 await rm(orphanInbox, { force: true });
+// A future lease owned by a dead PID must not hide the orphan until expiry.
+await writeJson(path.join(queueDirFor(root, orphanQueue), 'queue.lock'), {
+  version: 1,
+  queue: orphanQueue,
+  pid: 2_147_483_647,
+  acquiredAt: new Date().toISOString(),
+  expiresAt: new Date(Date.now() + 60_000).toISOString()
+});
 await writeJson(path.join(taskRuntimeDirFor(root, orphanQueue, orphanRouted.task.id), 'checkpoints', 'cp-before-crash.json'), {
   version: 1,
   task_id: orphanRouted.task.id,
@@ -118,6 +127,7 @@ assert.ok(orphanRun.progress.some((event) => event.status === 'orphan_recovered'
 const orphanTerminal = await readJson(path.join(root, orphanRun.taskPath));
 assert.equal(orphanTerminal.orphanRecoveryCount, 1);
 assert.equal(orphanTerminal.requeuedFrom, 'active');
+assert.equal(orphanTerminal.recoveryReason, 'dead_queue_lock_owner_pid');
 assert.equal((await readJson(path.join(taskRuntimeDirFor(root, orphanQueue, orphanRouted.task.id), 'checkpoints', 'cp-before-crash.json'))).checkpoint_id, 'cp-before-crash');
 
 const reviewQueue = 'human-review-smoke';
@@ -373,7 +383,7 @@ assert.equal(gateSent.sent, 1);
 const gateId = gateSent.results[0].gateId;
 assert.equal((await readJson(path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(failedFile)))).status, 'waiting_for_human');
 await assert.rejects(access(failedFile));
-const resolved = await resolveHumanInput(root, { queue, gateId, input: '123456', sourceMessageId: 'reply-1' });
+const resolved = await resolveHumanInput(root, { queue, gateId, input: '123456', sourceMessageId: 'reply-1', secretInput: true });
 assert.equal(resolved.outcome, 'resolved_and_requeued');
 const requeuedTask = await readJson(path.join(queueSubdirFor(root, queue, 'inbox'), path.basename(failedFile)));
 assert.equal(requeuedTask.humanInput.secret_received, true);
@@ -382,6 +392,43 @@ const resolvedGate = await readJson(path.join(root, resolved.ledger ?? gateSent.
 assert.equal(JSON.stringify(resolvedGate).includes('123456'), false);
 assert.equal(resolvedGate.response_sha256.length, 64);
 
+// Non-sensitive decisions and attestations remain available to the next worker
+// tick instead of being destroyed like OTPs and credentials.
+const attestationCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-attestation.json');
+await writeJson(attestationCheckpoint, {
+  version: 1, task_id: routed.task.id, checkpoint_id: 'cp-attestation', status: 'needs_human_input',
+  blockers: [{ id: 'review-decision', reason: 'Provide the independent review decision.' }],
+  verification: [], risks: [], next_action: 'wait'
+});
+await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+const attestationGateId = `${routed.task.id}:cp-attestation`;
+const attestationResolved = await resolveHumanInput(root, {
+  queue,
+  gateId: attestationGateId,
+  input: 'Reviewer accepts the candidate for the next gated stage.'
+});
+assert.equal(attestationResolved.gate.input_kind, 'attestation');
+assert.equal(attestationResolved.gate.secret_received, false);
+assert.equal(attestationResolved.gate.response, 'Reviewer accepts the candidate for the next gated stage.');
+assert.equal(attestationResolved.gate.response_ref, undefined);
+
+// A project-in-progress judgement with a newer effective checkpoint must not
+// resurrect historical waiting gates from older checkpoints.
+const attestationDoneCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-attestation-done.json');
+await writeJson(attestationDoneCheckpoint, {
+  version: 1, task_id: routed.task.id, checkpoint_id: 'cp-attestation-done',
+  revises_checkpoint_id: 'cp-attestation', sequence: 2, status: 'ready_for_acceptance',
+  blockers: [], verification: [{ observation: 'attestation', result: 'accepted' }], risks: [], next_action: 'continue'
+});
+const finalJudgementFile = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'final_judgement.json');
+await writeJson(finalJudgementFile, {
+  version: 1, task_id: routed.task.id, outcome: 'project_in_progress',
+  coverage: { effective_review_ids: ['cp-attestation-done'] }
+});
+const noHistoricalGateReplay = await notifyHumanInputRequests(root, { queue, dryRun: true });
+assert.equal(noHistoricalGateReplay.inspected, 0);
+await rm(finalJudgementFile, { force: true });
+
 // Queued tasks receive a non-sensitive event reference without being moved.
 const queuedCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-queued.json');
 await writeJson(queuedCheckpoint, {

package/skills/taskforce-loop-engineering/SKILL.md

@@ -216,7 +216,7 @@ loop-engineering queue-revision-next --root <workspace> --queue <queue> --task-i
 loop-engineering queue-lineage --root <workspace> --queue <queue> --task-id <id>
 loop-engineering queue-lineage-bundle --root <workspace> --queue <queue> --task-id <id>
 loop-engineering queue-human-decision --root <workspace> --queue <queue> --task-id <id> --decision approve|request_changes|reject
-loop-engineering queue-human-input-resolve --root <workspace> --queue <queue> --gate-id <task:checkpoint> --input "<response>"
+loop-engineering queue-human-input-resolve --root <workspace> --queue <queue> --gate-id <task:checkpoint> --input "<response>" [--secret-input|--non-secret-input]
 loop-engineering queue-terminal-notify --root <workspace> --queue <queue> (--notify-command "<command>" | --dry-run)
 loop-engineering queue-human-input-notify --root <workspace> --queue <queue> (--notify-command "<command>" | --dry-run)
 ```