@xdxer/dingtalk-agent 0.1.5-beta.1 → 0.1.5-beta.3

package/dist/src/multica-deploy.js

@@ -3,11 +3,9 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve } from 'node:path';
-import { WORKSPACE_STATE_ROOT, inspectAgentProject, showDevelopmentWorkspace, } from './development-workspace.js';
+import { WORKSPACE_STATE_ROOT, inspectAgentProject, projectSkillRef, showDevelopmentWorkspace, } from './development-workspace.js';
 import { digest, stableStringify } from './events.js';
-import { MULTICA_BOOT_SKILL, MULTICA_EVIDENCE_ROOT, inspectMulticaWorkspace, planMulticaWorkspace, statusMulticaWorkspace, } from './multica-provider.js';
-import { resolvePackageRoot } from './package-root.js';
-import { bundledSkillPath } from './skill-manager.js';
+import { MULTICA_EVIDENCE_ROOT, inspectMulticaWorkspace, planMulticaWorkspace, statusMulticaWorkspace, } from './multica-provider.js';
 export const MULTICA_DEPLOYMENT_SCHEMA = 'dingtalk-agent/multica-deployment-receipt@1';
 const MAX_DEPLOY_SKILLS = 32;
 const MAX_SKILL_SUPPORTING_FILES = 128;
@@ -21,6 +19,163 @@ class DeploymentFailure extends Error {
         this.ambiguous = ambiguous;
     }
 }
+export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt)
+        throw new Error('workspace run prompt 不能为空');
+    if (Buffer.byteLength(normalizedPrompt, 'utf8') > 64 * 1024) {
+        throw new Error('workspace run prompt 不能超过 65536 bytes');
+    }
+    rejectCredentialMaterial(normalizedPrompt, 'workspace run prompt');
+    const env = options.env || process.env;
+    const cliVersion = options.cliVersion || '';
+    const info = inspectAgentProject(start, cliVersion);
+    requireMulticaWorkspace(info.root, name, cliVersion);
+    const providerPlan = planMulticaWorkspace(info.root, name, { env, cliVersion });
+    const blocking = [...providerPlan.blocking];
+    if (!providerPlan.expected.agentId)
+        blocking.push('agent-id.missing');
+    const plan = {
+        $schema: 'dingtalk-agent/multica-workspace-run-plan@1',
+        workspace: name,
+        provider: 'multica',
+        profile: providerPlan.profile,
+        workspaceId: providerPlan.expected.workspaceId,
+        runtimeId: providerPlan.expected.runtimeId,
+        agentId: providerPlan.expected.agentId,
+        promptHash: sha256(normalizedPrompt),
+        operations: ['scope.inspect', 'issue.create', 'issue.runs', 'issue.run-messages', 'evidence.persist'],
+        blocking: [...new Set(blocking)].sort(),
+        requiresExecute: true,
+        requiresExplicitYes: true,
+        remoteRead: false,
+        remoteWrite: false,
+        triggerWrite: false,
+        sideEffect: false,
+        dingtalkSideEffect: false,
+    };
+    if (!options.execute)
+        return plan;
+    if (!options.yes) {
+        throw new Error('Multica workspace run 会创建远端 Issue；必须同时传 --execute --yes');
+    }
+    if (plan.blocking.length) {
+        throw new Error(`Multica workspace run 前置条件不完整: ${plan.blocking.join(', ')}`);
+    }
+    const command = options.command || env.DTA_MULTICA_BIN || 'multica';
+    const timeoutMs = positiveTimeout(options.timeoutMs, 30_000, 300_000);
+    const calls = [];
+    const inspection = inspectMulticaWorkspace(info.root, name, {
+        execute: true, yes: true, persist: false, command, env,
+        timeoutMs: Math.min(timeoutMs, 30_000), cliVersion,
+    });
+    appendInspectionCalls(inspection, 'run.preflight', calls);
+    const assignedSkills = inspection.resources.assignedSkills
+        .filter((item) => item.enabled).map((item) => item.name).sort();
+    const expectedSkills = [...providerPlan.expected.skills].sort();
+    if (!inspection.passed || inspection.resources.workspace?.id !== plan.workspaceId ||
+        inspection.resources.runtime?.id !== plan.runtimeId ||
+        inspection.resources.agent?.id !== plan.agentId ||
+        stableStringify(assignedSkills) !== stableStringify(expectedSkills)) {
+        throw new Error('Multica workspace run scope 或 Skill assignment 与 Project 不一致；未创建 Issue');
+    }
+    const runId = `multica_workspace_run_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const marker = `DTA-WORKSPACE-RUN-${randomUUID()}`;
+    const issue = jsonObject(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
+        'issue', 'create', '--title', `[DTA workspace run] ${marker}`,
+        '--description', normalizedPrompt, '--assignee-id', plan.agentId, '--output', 'json',
+    ]), 'workspace-run.issue.create', 'write', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run issue');
+    const issueId = resourceId(issue.id, 'workspace run issue.id');
+    const started = Date.now();
+    const pollIntervalMs = 2_000;
+    const pollCalls = [];
+    let pollAttempts = 0;
+    let task;
+    while (Date.now() - started < timeoutMs) {
+        pollAttempts += 1;
+        const runs = jsonArray(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
+            'issue', 'runs', issueId, '--full-id', '--output', 'json',
+        ]), 'workspace-run.issue.runs', 'read', info.root, env, Math.min(timeoutMs, 30_000), pollCalls).stdout, 'workspace run issue runs');
+        task = runs.filter((item) => !optionalString(item.agent_id) ||
+            optionalString(item.agent_id) === plan.agentId)
+            .sort((a, b) => optionalString(b.created_at).localeCompare(optionalString(a.created_at)))[0];
+        const status = optionalString(task?.status);
+        if (['completed', 'failed', 'cancelled'].includes(status))
+            break;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, pollIntervalMs);
+    }
+    calls.push(...uniqueCalls(pollCalls));
+    const taskId = task?.id ? resourceId(task.id, 'workspace run task.id') : '';
+    const taskStatus = optionalString(task?.status) || 'not-created';
+    let messages = [];
+    if (taskId && ['completed', 'failed', 'cancelled'].includes(taskStatus)) {
+        messages = jsonArray(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
+            'issue', 'run-messages', taskId, '--issue', issueId, '--output', 'json',
+        ]), 'workspace-run.issue.messages', 'read', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run messages');
+    }
+    const toolUses = messages.filter((item) => optionalString(item.type) === 'tool_use');
+    const toolNames = toolUses.map((item) => optionalString(item.tool)).filter(Boolean);
+    const loadedSkills = toolUses.filter((item) => optionalString(item.tool) === 'skill')
+        .map((item) => optionalString(smokeToolInput(item).name)).filter(Boolean);
+    const texts = messages.filter((item) => optionalString(item.type) === 'text')
+        .map((item) => optionalString(item.content)).filter(Boolean);
+    const replyWrites = toolUses.filter((item) => optionalString(item.tool) === 'write')
+        .map((item) => smokeToolInput(item)).filter((input) => optionalString(input.filePath).endsWith('/reply.md'))
+        .map((input) => optionalString(input.content)).filter(Boolean);
+    const answer = safeRemoteOutput(replyWrites.at(-1) || texts.at(-1) || '', 64 * 1024);
+    const issueReadback = jsonObject(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
+        'issue', 'get', issueId, '--output', 'json',
+    ]), 'workspace-run.issue.readback', 'read', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run issue readback');
+    const issueStatus = optionalString(issueReadback.status);
+    const failures = [];
+    if (!task)
+        failures.push('task.not-created');
+    else if (!['completed', 'failed', 'cancelled'].includes(taskStatus))
+        failures.push('task.timeout');
+    else if (taskStatus !== 'completed')
+        failures.push(`task.${taskStatus}`);
+    if (!answer)
+        failures.push('answer.missing');
+    const taskDiagnostic = task
+        ? remoteTaskDiagnostic(task)
+        : `未发现关联 task；Issue 状态=${issueStatus || 'unknown'}，已轮询 ${pollAttempts} 次`;
+    const report = {
+        $schema: 'dingtalk-agent/multica-workspace-run@1',
+        passed: failures.length === 0,
+        runId,
+        workspace: name,
+        provider: 'multica',
+        profile: plan.profile,
+        workspaceId: plan.workspaceId,
+        runtimeId: plan.runtimeId,
+        agentId: plan.agentId,
+        promptHash: plan.promptHash,
+        issueId,
+        issueStatus,
+        taskId,
+        taskStatus,
+        taskDiagnostic,
+        pollAttempts,
+        pollIntervalMs,
+        answer,
+        answerHash: sha256(answer),
+        toolNames,
+        loadedSkills,
+        failures,
+        calls,
+        evidencePath: '',
+        remoteRead: true,
+        remoteWrite: true,
+        triggerWrite: false,
+        sideEffect: 'multica-issue-read-write',
+        dingtalkSideEffect: false,
+    };
+    const defaultEvidence = join(MULTICA_EVIDENCE_ROOT, safeName(name), 'multica-runs', `${runId}.json`);
+    report.evidencePath = relative(info.root, safeProjectPath(info.root, options.out || defaultEvidence, false));
+    assertReportRedacted(report);
+    atomicJson(safeProjectPath(info.root, report.evidencePath, false), report);
+    return report;
+}
 export function planMulticaDeployment(start, name, options = {}) {
     const action = options.action || 'apply';
     const env = options.env || process.env;
@@ -53,12 +208,12 @@ export function planMulticaDeployment(start, name, options = {}) {
         : [
             'scope.reinspect', 'skills.readback', 'skills.reconcile', 'agent.reconcile',
             'skills.assign-exact', 'provider.readback', 'load-smoke.create',
-            'load-smoke.readback', 'receipt.persist',
+            'load-smoke.recover-if-unstarted', 'load-smoke.readback', 'receipt.persist',
         ];
     const writeBudget = action === 'retire'
         ? { forward: 1, rollback: 0 }
         : {
-            forward: source.skills.length * (1 + MAX_SKILL_SUPPORTING_FILES * 2) + 4,
+            forward: source.skills.length * (1 + MAX_SKILL_SUPPORTING_FILES * 2) + 5,
             rollback: source.skills.length * (1 + MAX_SKILL_SUPPORTING_FILES * 2) + 3,
         };
     const planId = `multica_deploy_plan_${digest(stableStringify({
@@ -344,15 +499,9 @@ function loadDeploymentSource(root) {
     const definitionHash = sha256(definition);
     const skillRoots = [];
     for (const name of info.project.skills) {
-        const ref = name === 'dingtalk-basic-behavior'
-            ? `.agents/skills/${name}` : `skills/${name}`;
+        const ref = projectSkillRef(info.project, name);
         skillRoots.push({ name, root: safeProjectPath(root, ref, true) });
     }
-    const packageRoot = resolvePackageRoot(import.meta.url);
-    skillRoots.push({
-        name: MULTICA_BOOT_SKILL,
-        root: safeExternalSkillRoot(bundledSkillPath(packageRoot, MULTICA_BOOT_SKILL)),
-    });
     if (skillRoots.length > MAX_DEPLOY_SKILLS) {
         throw new Error(`Multica deploy 最多支持 ${MAX_DEPLOY_SKILLS} 个受管 Skills`);
     }
@@ -361,26 +510,17 @@ function loadDeploymentSource(root) {
     if (new Set(skills.map((item) => item.name)).size !== skills.length) {
         throw new Error('Multica deploy required Skills 不能重名');
     }
-    const required = skills.map((item) => ({ name: item.name, sha256: item.hash }));
-    const deploymentSourceHash = digest(stableStringify({ definitionHash, required }));
-    const instructions = [
-        '<!-- DTA Multica Boot: managed; do not edit remotely -->',
-        `definition_sha256=${definitionHash}`,
-        `deployment_sha256=${deploymentSourceHash}`,
-        `required_skills=${JSON.stringify(required)}`,
-        'Before every task, use dingtalk-agent-boot-multica and follow its startup order.',
-        'Never create a robot, webhook, autopilot, schedule, or other Trigger as part of deployment.',
-        '<!-- /DTA Multica Boot -->',
-        '',
-        definition.trimEnd(),
-        '',
-    ].join('\n');
+    // Agent instructions are the human-authored Definition, byte for byte. Deployment
+    // hashes and the managed Skill set belong to the control plane and its Receipt;
+    // injecting them into the System Prompt makes the role unreadable and creates a
+    // second runtime protocol beside the Host's native Skill assignment.
+    const instructions = definition;
     const instructionsHash = sha256(instructions);
     const deploymentHash = digest(stableStringify({
         definitionHash, instructionsHash,
         skills: skills.map((item) => ({ name: item.name, hash: item.hash })),
     }));
-    return { definition, definitionHash, instructions, instructionsHash, skills, deploymentHash };
+    return { definitionHash, instructions, instructionsHash, skills, deploymentHash };
 }
 function loadSkillBundle(name, root) {
     const actual = realpathSync(root);
@@ -560,24 +700,51 @@ function upsertSkillFile(root, plan, skillId, path, contentFile, command, env, t
 function createAndReadSmoke(root, plan, source, agentId, command, env, timeoutMs, smokeTimeoutMs, noWait, calls) {
     const marker = `DTA-MULTICA-LOAD-${randomUUID()}`;
     const requiredSkills = source.skills.map((item) => item.name).sort();
+    const expectedResponse = JSON.stringify({
+        schema: 'dta-multica-load-smoke@1', marker, loaded: requiredSkills,
+    });
     const issue = jsonObject(runProvider(command, scopedArgs(plan, [
         'issue', 'create', '--title', `[DTA load smoke] ${marker}`,
         '--description', [
             'DTA_MULTICA_LOAD_SMOKE@1', `marker=${marker}`,
-            'Use only the trusted DTA Multica Boot required_skills list.',
-            'Do not call DWS, Shell, network, or write tools.',
+            `required_skills=${JSON.stringify(requiredSkills)}`,
+            'This is a deployment control-plane verification task.',
+            'Use the Host native Skill tool exactly once for every required skill above, in the listed order.',
+            'Do not call DWS, network, or business tools. Only the Host Issue control-plane calls needed to read this Issue and persist the exact result are exempt.',
+            `Return exactly this JSON and nothing else: ${expectedResponse}`,
         ].join('\n'),
         '--assignee-id', agentId, '--output', 'json',
     ]), 'smoke.issue.create', 'write', root, env, timeoutMs, calls).stdout, 'smoke issue');
     const issueId = resourceId(issue.id, 'smoke issue.id');
+    let smoke = readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls);
+    // Multica persists the Issue before attempting the initial agent enqueue. If
+    // that enqueue loses a transient readiness race, the API still returns a
+    // valid assigned todo Issue but issue runs remains empty forever. Recover
+    // exactly that observable state once through an explicit ID-bound mention on
+    // the same Issue. A visible task — queued, running or terminal — is never
+    // duplicated. The mention route is used instead of issue rerun because it is
+    // the platform's normal first-run trigger and does not require a prior task.
+    if (smoke.status === 'pending' && !smoke.taskId) {
+        runProvider(command, scopedArgs(plan, [
+            'issue', 'comment', 'add', issueId,
+            '--content', `[@DTA load smoke](mention://agent/${agentId}) Execute the deployment verification exactly as specified in this Issue description.`,
+            '--output', 'json',
+        ]), 'smoke.issue.recover', 'write', root, env, timeoutMs, calls);
+        smoke = readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls);
+    }
     if (noWait)
-        return readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls);
+        return smoke;
     const started = Date.now();
-    let smoke = readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls);
     while (smoke.status === 'pending' && Date.now() - started < smokeTimeoutMs) {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2_000);
         smoke = readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls);
     }
+    if (smoke.status === 'pending' && !smoke.taskDiagnostic) {
+        const detail = smoke.taskId
+            ? `task ${smoke.taskId} 在 ${smokeTimeoutMs}ms 内未进入终态（当前 ${smoke.taskStatus || 'unknown'}）`
+            : `Issue ${issueId} 在 ${smokeTimeoutMs}ms 内未创建关联 task`;
+        return { ...smoke, taskDiagnostic: detail };
+    }
     return smoke;
 }
 function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command, env, timeoutMs, calls) {
@@ -607,10 +774,15 @@ function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command
         .map((item) => optionalString(item.content)).filter(Boolean);
     const finalText = texts.at(-1) || '';
     const matchesResponse = (value) => smokeResponseMatches(value, marker, requiredSkills);
-    const replyWrites = toolUses.filter((item) => optionalString(item.tool) === 'write')
-        .map((item) => smokeToolInput(item)).filter((input) => optionalString(input.filePath).endsWith('/reply.md'))
+    const responseWrites = toolUses.filter((item) => optionalString(item.tool) === 'write')
+        .map((item) => smokeToolInput(item)).filter((input) => safeSmokeResponsePath(optionalString(input.filePath)))
         .map((input) => optionalString(input.content)).filter(Boolean);
-    const responseEvidence = [...texts, ...replyWrites].find(matchesResponse) || '';
+    const responseShells = toolUses.filter((item) => optionalString(item.tool) === 'bash')
+        .map((item) => optionalString(smokeToolInput(item).command))
+        .filter((command) => safeCombinedSmokeResponse(command, issueId, marker, requiredSkills))
+        .map(() => JSON.stringify({ schema: 'dta-multica-load-smoke@1', marker, loaded: requiredSkills }));
+    const responseEvidence = [...texts, ...responseWrites, ...responseShells]
+        .find(matchesResponse) || '';
     const responsePassed = Boolean(responseEvidence);
     const toolTracePassed = toolUses.every((item) => allowedSmokeToolUse(item, issueId, marker, requiredSkills)) && stableStringify(skillNames) === stableStringify(requiredSkills);
     const failures = [];
@@ -621,8 +793,8 @@ function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command
     if (!responsePassed)
         failures.push('smoke.response');
     return {
-        status: failures.length ? 'failed' : 'passed',
-        marker, markerHash: sha256(marker), issueId, taskId, taskStatus, requiredSkills, loadedSkills,
+        status: failures.length ? 'failed' : 'passed', marker, markerHash: sha256(marker),
+        issueId, taskId, taskStatus, taskDiagnostic: remoteTaskDiagnostic(run), requiredSkills, loadedSkills,
         toolTracePassed, responsePassed, responseHash: sha256(responseEvidence || finalText), failures,
     };
 }
@@ -647,7 +819,7 @@ function allowedSmokeToolUse(item, issueId, marker, requiredSkills) {
         return true;
     const input = smokeToolInput(item);
     if (tool === 'write') {
-        return safeSmokeReplyPath(optionalString(input.filePath)) &&
+        return safeSmokeResponsePath(optionalString(input.filePath)) &&
             smokeResponseMatches(optionalString(input.content), marker, requiredSkills);
     }
     if (tool !== 'bash')
@@ -663,30 +835,45 @@ function allowedSmokeToolUse(item, issueId, marker, requiredSkills) {
         return true;
     const commentPrefix = `multica issue comment add ${issueId} --content-file `;
     if (command.startsWith(commentPrefix)) {
-        return safeSmokeReplyPath(command.slice(commentPrefix.length));
+        return safeSmokeResponsePath(command.slice(commentPrefix.length));
     }
     const cleanupFirstPrefix = 'rm ';
     const cleanupFirstSuffix = ` && multica issue status ${issueId} in_review`;
     if (command.startsWith(cleanupFirstPrefix) && command.endsWith(cleanupFirstSuffix)) {
-        return safeSmokeReplyPath(command.slice(cleanupFirstPrefix.length, command.length - cleanupFirstSuffix.length));
+        return safeSmokeCleanup(command.slice(cleanupFirstPrefix.length, command.length - cleanupFirstSuffix.length));
     }
     const statusFirstPrefix = `multica issue status ${issueId} in_review && rm `;
     if (command.startsWith(statusFirstPrefix)) {
-        return safeSmokeReplyPath(command.slice(statusFirstPrefix.length));
+        return safeSmokeCleanup(command.slice(statusFirstPrefix.length));
     }
     if (command.startsWith(cleanupFirstPrefix)) {
-        return safeSmokeReplyPath(command.slice(cleanupFirstPrefix.length));
+        return safeSmokeCleanup(command.slice(cleanupFirstPrefix.length));
     }
+    if (safeCombinedSmokeResponse(command, issueId, marker, requiredSkills))
+        return true;
     return false;
 }
-function safeSmokeReplyPath(value) {
-    if (value === './reply.md')
-        return true;
-    if (!value.startsWith('/') || !value.endsWith('/reply.md'))
+function safeCombinedSmokeResponse(command, issueId, marker, requiredSkills) {
+    const response = JSON.stringify({ schema: 'dta-multica-load-smoke@1', marker, loaded: requiredSkills });
+    return command === [
+        "cat > ./reply.md << 'REPLY_EOF'",
+        response,
+        'REPLY_EOF',
+        `multica issue comment add ${issueId} --content-file ./reply.md && rm ./reply.md`,
+    ].join('\n');
+}
+function safeSmokeResponsePath(value) {
+    const names = new Set(['reply.md', 'result.md', 'result.json']);
+    if (value.startsWith('./'))
+        return names.has(value.slice(2));
+    if (!value.startsWith('/') || !names.has(value.split('/').at(-1) || ''))
         return false;
     return value.split('/').every((part) => !part ||
         (part !== '.' && part !== '..' && /^[A-Za-z0-9._-]+$/.test(part)));
 }
+function safeSmokeCleanup(value) {
+    return safeSmokeResponsePath(value.startsWith('-f ') ? value.slice(3) : value);
+}
 function rollbackConfirmed(root, plan, command, env, timeoutMs, calls, rollback, temp) {
     const report = emptyRollback(true);
     const attempt = (id, argv) => {
@@ -1356,7 +1543,7 @@ function assertReportRedacted(value) {
 }
 function emptySmoke(status, requiredSkills) {
     return {
-        status, marker: '', markerHash: '', issueId: '', taskId: '', taskStatus: '',
+        status, marker: '', markerHash: '', issueId: '', taskId: '', taskStatus: '', taskDiagnostic: '',
         requiredSkills: [...requiredSkills].sort(), loadedSkills: [],
         toolTracePassed: false, responsePassed: false, responseHash: '', failures: [],
     };
@@ -1432,6 +1619,58 @@ function stringField(value, label) {
 function optionalString(value) {
     return typeof value === 'string' ? value : '';
 }
+function safeRemoteOutput(value, maxBytes) {
+    const redacted = value
+        .replace(/-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g, '[redacted-private-key]')
+        .replace(/\bBearer\s+[A-Za-z0-9._~+\/-]{20,}/gi, 'Bearer [redacted]')
+        .replace(/\b(?:mul_|mcn_|sk-)[A-Za-z0-9._~+\/-]{12,}/gi, '[redacted-token]');
+    const bytes = Buffer.from(redacted, 'utf8');
+    return bytes.length <= maxBytes ? redacted : `${bytes.subarray(0, maxBytes).toString('utf8')}…`;
+}
+function uniqueCalls(calls) {
+    const seen = new Set();
+    return calls.filter((call) => {
+        const key = stableStringify({
+            id: call.id,
+            kind: call.kind,
+            argv: call.argv,
+            exitCode: call.exitCode,
+            stdoutHash: call.stdoutHash,
+            stderrHash: call.stderrHash,
+            passed: call.passed,
+            ambiguous: call.ambiguous,
+        });
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function remoteTaskDiagnostic(task) {
+    if (!task)
+        return '';
+    const values = [];
+    const add = (label, value) => {
+        if (typeof value === 'string' && value.trim())
+            values.push(`${label}=${value.trim()}`);
+        else if (typeof value === 'number' || typeof value === 'boolean')
+            values.push(`${label}=${value}`);
+        else if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const nested = value;
+            for (const key of ['code', 'category', 'message', 'reason', 'detail']) {
+                if (nested[key] !== undefined)
+                    add(`${label}.${key}`, nested[key]);
+            }
+        }
+    };
+    for (const key of [
+        'error', 'error_message', 'failure_reason', 'status_message', 'reason', 'message', 'detail',
+    ]) {
+        if (task[key] !== undefined)
+            add(key, task[key]);
+    }
+    return safeRemoteOutput(values.join('; '), 2_000);
+}
 function resourceId(value, label) {
     const item = stringField(value, label);
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{1,127}$/.test(item) ||
@@ -1454,12 +1693,6 @@ function requireMulticaWorkspace(start, name, cliVersion = '') {
     }
     return workspace;
 }
-function safeExternalSkillRoot(path) {
-    if (!existsSync(path) || lstatSync(path).isSymbolicLink()) {
-        throw new Error(`Canonical Multica Boot Skill 不存在或是符号链接: ${path}`);
-    }
-    return realpathSync(path);
-}
 function safeProjectPath(root, ref, mustExist) {
     const rootReal = realpathSync(resolve(root));
     const candidate = resolve(rootReal, ref);