commandmate 0.15.0 → 0.17.0

package/dist/server/src/lib/skills/compatibility.js

@@ -3,8 +3,8 @@
  * CommandMate compatibility judgement and version resolution (Issue #1231)
  *
  * Pure functions: no filesystem, no network, no process state. The host version
- * is always an explicit argument so UI, API and CLI can evaluate the same
- * Catalog against the same rules and reach the same verdict.
+ * and the current instant are always explicit arguments so UI, API and CLI can
+ * evaluate the same Catalog against the same rules and reach the same verdict.
  *
  * Every verdict carries a stable machine code *and* a human-readable message
  * (受入条件: "互換性NGの理由がmachine-readable codeとhuman-readable messageで返る").
@@ -14,16 +14,19 @@
  * @module lib/skills/compatibility
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SkillRecommendationReason = exports.UNKNOWN_HOST_VERSION_SENTINEL = exports.SKILL_COMPATIBILITY_MESSAGE_KEYS = exports.SkillCompatibilityReason = void 0;
+exports.SkillRecommendationReason = exports.SKILL_AGENT_VERIFICATION_MESSAGE_KEYS = exports.SkillAgentVerification = exports.UNKNOWN_HOST_VERSION_SENTINEL = exports.SKILL_COMPATIBILITY_MESSAGE_KEYS = exports.SkillCompatibilityReason = void 0;
 exports.normalizeHostVersion = normalizeHostVersion;
 exports.evaluateCommandMateCompatibility = evaluateCommandMateCompatibility;
 exports.evaluateVersionCompatibility = evaluateVersionCompatibility;
+exports.capSupportByMeasurement = capSupportByMeasurement;
+exports.reconcileAgentSupport = reconcileAgentSupport;
 exports.describeAgentCompatibility = describeAgentCompatibility;
 exports.resolveSkillVersions = resolveSkillVersions;
 exports.findSkillCatalogEntry = findSkillCatalogEntry;
 // Sibling modules of the same package are imported directly rather than through
 // the `@/lib/skills` barrel, so adding this module to the barrel later can never
 // introduce an import cycle. External callers still go through the barrel.
+const compatibility_matrix_1 = require("../../lib/skills/compatibility-matrix");
 const constants_1 = require("../../lib/skills/constants");
 const semver_1 = require("../../lib/skills/semver");
 /** Stable reason codes for a CommandMate compatibility verdict. */
@@ -122,14 +125,132 @@ function evaluateCommandMateCompatibility(requiredRange, currentVersion) {
 function evaluateVersionCompatibility(version, currentVersion) {
     return evaluateCommandMateCompatibility(version.compatibility.commandmate, currentVersion);
 }
-/** Attach the shared i18n label key to each Agent support claim. */
-function describeAgentCompatibility(agents) {
-    return agents.map((entry) => ({
-        agent: entry.agent,
-        support: entry.support,
-        labelKey: constants_1.AGENT_SUPPORT_LABEL_KEYS[entry.support],
-        evidence: entry.evidence,
-    }));
+// =============================================================================
+// Agent compatibility
+// =============================================================================
+/**
+ * How the publisher's declaration stands up against what CommandMate measured
+ * (Issue #1246).
+ */
+exports.SkillAgentVerification = {
+    /** Declaration and measurement agree. */
+    CONFIRMED: 'SKILL_AGENT_EVIDENCE_CONFIRMED',
+    /** Measurement is weaker than the declaration, so the declaration is capped. */
+    RESTRICTED: 'SKILL_AGENT_EVIDENCE_RESTRICTED',
+    /** Measurement is stronger than the declaration; the manifest has fallen behind. */
+    STALE_DECLARATION: 'SKILL_AGENT_EVIDENCE_STALE_DECLARATION',
+    /** CommandMate has never measured this Agent. */
+    UNVERIFIED: 'SKILL_AGENT_EVIDENCE_UNVERIFIED',
+};
+exports.SKILL_AGENT_VERIFICATION_MESSAGE_KEYS = {
+    [exports.SkillAgentVerification.CONFIRMED]: 'skills.compatibility.verification.confirmed',
+    [exports.SkillAgentVerification.RESTRICTED]: 'skills.compatibility.verification.restricted',
+    [exports.SkillAgentVerification.STALE_DECLARATION]: 'skills.compatibility.verification.staleDeclaration',
+    [exports.SkillAgentVerification.UNVERIFIED]: 'skills.compatibility.verification.unverified',
+};
+/**
+ * Ordering used to cap a declaration by a measurement. Higher is stronger.
+ *
+ * `unknown` outranks `unsupported` because "we could not tell" leaves more room
+ * than "we established it does not work".
+ */
+const AGENT_SUPPORT_RANK = {
+    unsupported: 0,
+    unknown: 1,
+    commandmate_runtime: 2,
+    native: 3,
+};
+/**
+ * Cap a publisher's declaration by what CommandMate measured.
+ *
+ * Downward only. A weaker measurement wins, which is what keeps an
+ * evidence-free `native` off the screen. A stronger one does not: raising a
+ * package's own claim is the publisher's call, so the mismatch is reported as
+ * a declaration that has fallen behind.
+ */
+function capSupportByMeasurement(declared, measured) {
+    const declaredRank = AGENT_SUPPORT_RANK[declared];
+    const measuredRank = AGENT_SUPPORT_RANK[measured];
+    if (measuredRank < declaredRank) {
+        return { support: measured, verification: exports.SkillAgentVerification.RESTRICTED };
+    }
+    if (measuredRank > declaredRank) {
+        return { support: declared, verification: exports.SkillAgentVerification.STALE_DECLARATION };
+    }
+    return { support: declared, verification: exports.SkillAgentVerification.CONFIRMED };
+}
+function toAxisView(axis, evidence) {
+    return {
+        axis,
+        axisKey: compatibility_matrix_1.AGENT_AXIS_LABEL_KEYS[axis],
+        outcome: evidence.outcome,
+        outcomeKey: evidence.labelKey,
+        evidenceKind: evidence.evidenceKind,
+        evidenceKindKey: evidence.evidenceKindKey,
+        limitationKey: evidence.limitationKey,
+    };
+}
+function toMeasuredView(entry, now) {
+    return {
+        discovery: toAxisView('discovery', entry.discovery),
+        invocation: toAxisView('invocation', entry.invocation),
+        discoveryRoots: [...entry.discoveryRoots],
+        testedVersion: entry.testedVersion,
+        testedDate: entry.testedDate,
+        evidenceSource: entry.evidenceSource,
+        ageDays: (0, compatibility_matrix_1.evidenceAgeInDays)(entry, now),
+        stale: (0, compatibility_matrix_1.isEvidenceStale)(entry, now),
+    };
+}
+/**
+ * Reconcile one declared Agent claim with the measured discovery matrix.
+ *
+ * The declaration is never rewritten upward: a measurement stronger than the
+ * manifest is reported as a stale declaration, not silently promoted, because
+ * the publisher is the one who decides what their package claims to support.
+ * It *is* capped downward, which is what keeps "evidence-free native" off the
+ * screen when a manifest asserts an Agent CommandMate measured as unsupported.
+ */
+function reconcileAgentSupport(declared, now) {
+    const entry = (0, compatibility_matrix_1.findSkillAgentMatrixEntry)(declared.agent);
+    const base = {
+        agent: declared.agent,
+        evidence: declared.evidence,
+        declaredSupport: declared.support,
+        declaredLabelKey: constants_1.AGENT_SUPPORT_LABEL_KEYS[declared.support],
+    };
+    if (entry === null || !(0, compatibility_matrix_1.isAgentMeasured)(entry)) {
+        return {
+            ...base,
+            support: declared.support,
+            labelKey: constants_1.AGENT_SUPPORT_LABEL_KEYS[declared.support],
+            verification: exports.SkillAgentVerification.UNVERIFIED,
+            verificationKey: exports.SKILL_AGENT_VERIFICATION_MESSAGE_KEYS[exports.SkillAgentVerification.UNVERIFIED],
+            measured: null,
+            skipReasonKey: entry?.skipReasonKey ?? null,
+            reloadKey: entry?.reloadKey ?? compatibility_matrix_1.AGENT_RELOAD_MESSAGE_KEYS.UNKNOWN,
+        };
+    }
+    const { support, verification } = capSupportByMeasurement(declared.support, (0, compatibility_matrix_1.deriveMatrixAgentSupport)(entry));
+    return {
+        ...base,
+        support,
+        labelKey: constants_1.AGENT_SUPPORT_LABEL_KEYS[support],
+        verification,
+        verificationKey: exports.SKILL_AGENT_VERIFICATION_MESSAGE_KEYS[verification],
+        measured: toMeasuredView(entry, now),
+        skipReasonKey: null,
+        reloadKey: entry.reloadKey,
+    };
+}
+/**
+ * Attach the shared i18n label key and the measured evidence to each claim.
+ *
+ * @param now - Evaluated against for evidence staleness. Passed explicitly by
+ *   tests so a verdict never depends on when the suite runs.
+ */
+function describeAgentCompatibility(agents, now = new Date()) {
+    return agents.map((entry) => reconcileAgentSupport(entry, now));
 }
 // =============================================================================
 // Version resolution

package/dist/server/src/lib/skills/operation-audit.js

@@ -16,9 +16,11 @@
  * @module lib/skills/operation-audit
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILL_AUDIT_MAX_LIMIT = exports.SKILL_AUDIT_DEFAULT_LIMIT = void 0;
 exports.buildSkillOperationAuditInput = buildSkillOperationAuditInput;
 exports.recordSkillOperationAudit = recordSkillOperationAudit;
 exports.getSkillOperationAuditByOperationId = getSkillOperationAuditByOperationId;
+exports.querySkillOperationAudit = querySkillOperationAudit;
 exports.listSkillOperationAudit = listSkillOperationAudit;
 const crypto_1 = require("crypto");
 const operation_store_1 = require("../../lib/skills/operation-store");
@@ -36,6 +38,8 @@ function mapRow(row) {
         worktreeId: row.worktree_id,
         skillId: row.skill_id,
         skillVersion: row.skill_version,
+        fromVersion: row.from_version,
+        toVersion: row.to_version,
         sourceOrigin: row.source_origin,
         sourceRepository: row.source_repository,
         sourceRef: row.source_ref,
@@ -48,15 +52,23 @@ function mapRow(row) {
 }
 const SELECT_COLUMNS = `
   id, operation_id, idempotency_key, binding_hash, operation, state, result,
-  actor_type, actor_id, worktree_id, skill_id, skill_version,
+  actor_type, actor_id, worktree_id, skill_id, skill_version, from_version, to_version,
   source_origin, source_repository, source_ref, source_commit, artifact_sha256,
   error_code, error_message, recorded_at
 `;
 /**
  * Build an audit input from a journal entry, so the two records cannot drift.
  * The journal already holds the actor, target, source and typed error.
+ *
+ * The version transition (#1248) is derived from the journal rather than passed
+ * in, because for the two operations that exist today the journal fully
+ * determines it: an install ends at its target version and starts nowhere, an
+ * uninstall starts at the version it removes and ends nowhere. An `update` is
+ * the one case where `fromVersion` is not derivable — it has no writer yet
+ * (#1243/#1244), and whoever adds one has to supply the replaced version here.
  */
 function buildSkillOperationAuditInput(entry, result, recordedAt) {
+    const isUninstall = entry.operation === 'uninstall';
     return {
         operationId: entry.operationId,
         idempotencyKey: entry.idempotencyKey,
@@ -69,6 +81,8 @@ function buildSkillOperationAuditInput(entry, result, recordedAt) {
         worktreeId: entry.target.worktreeId,
         skillId: entry.target.skillId,
         skillVersion: entry.target.version,
+        fromVersion: isUninstall ? entry.target.version : null,
+        toVersion: isUninstall ? null : entry.target.version,
         sourceOrigin: entry.source?.origin ?? null,
         sourceRepository: entry.source?.repository ?? null,
         sourceRef: entry.source?.ref ?? null,
@@ -89,10 +103,10 @@ function recordSkillOperationAudit(db, input) {
     };
     db.prepare(`INSERT INTO skill_operations (
       id, operation_id, idempotency_key, binding_hash, operation, state, result,
-      actor_type, actor_id, worktree_id, skill_id, skill_version,
+      actor_type, actor_id, worktree_id, skill_id, skill_version, from_version, to_version,
       source_origin, source_repository, source_ref, source_commit, artifact_sha256,
       error_code, error_message, recorded_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.operationId, record.idempotencyKey, record.bindingHash, record.operation, record.state, record.result, record.actorType, record.actorId, record.worktreeId, record.skillId, record.skillVersion, record.sourceOrigin, record.sourceRepository, record.sourceRef, record.sourceCommit, record.artifactSha256, record.errorCode, record.errorMessage, record.recordedAt);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.operationId, record.idempotencyKey, record.bindingHash, record.operation, record.state, record.result, record.actorType, record.actorId, record.worktreeId, record.skillId, record.skillVersion, record.fromVersion, record.toVersion, record.sourceOrigin, record.sourceRepository, record.sourceRef, record.sourceCommit, record.artifactSha256, record.errorCode, record.errorMessage, record.recordedAt);
     return record;
 }
 /** Audit trail of one operation, oldest first. */
@@ -103,18 +117,74 @@ function getSkillOperationAuditByOperationId(db, operationId) {
         .all(operationId);
     return rows.map(mapRow);
 }
+/** Default page size for an audit query. */
+exports.SKILL_AUDIT_DEFAULT_LIMIT = 50;
+/** Hard ceiling on one audit page, so a client cannot ask for the whole log. */
+exports.SKILL_AUDIT_MAX_LIMIT = 200;
+function buildAuditWhere(query) {
+    const conditions = [];
+    const params = [];
+    if (query.worktreeId !== undefined) {
+        conditions.push('worktree_id = ?');
+        params.push(query.worktreeId);
+    }
+    if (query.skillId !== undefined) {
+        conditions.push('skill_id = ?');
+        params.push(query.skillId);
+    }
+    if (query.operation !== undefined) {
+        conditions.push('operation = ?');
+        params.push(query.operation);
+    }
+    if (query.result !== undefined) {
+        conditions.push('result = ?');
+        params.push(query.result);
+    }
+    if (query.since !== undefined) {
+        conditions.push('recorded_at >= ?');
+        params.push(query.since);
+    }
+    if (query.until !== undefined) {
+        conditions.push('recorded_at < ?');
+        params.push(query.until);
+    }
+    if (query.after !== undefined) {
+        conditions.push('(recorded_at < ? OR (recorded_at = ? AND id < ?))');
+        params.push(query.after.recordedAt, query.after.recordedAt, query.after.id);
+    }
+    return {
+        clause: conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '',
+        params,
+    };
+}
+/**
+ * One page of the audit feed, newest first.
+ *
+ * Fetches one row beyond the page to decide `hasMore` without a second COUNT
+ * over a table that only ever grows.
+ */
+function querySkillOperationAudit(db, query = {}) {
+    const limit = Math.min(Math.max(1, Math.trunc(query.limit ?? exports.SKILL_AUDIT_DEFAULT_LIMIT)), exports.SKILL_AUDIT_MAX_LIMIT);
+    const { clause, params } = buildAuditWhere(query);
+    const rows = db
+        .prepare(`SELECT ${SELECT_COLUMNS} FROM skill_operations
+       ${clause}
+       ORDER BY recorded_at DESC, id DESC LIMIT ?`)
+        .all(...params, limit + 1);
+    const hasMore = rows.length > limit;
+    const records = (hasMore ? rows.slice(0, limit) : rows).map(mapRow);
+    const last = records[records.length - 1];
+    return {
+        records,
+        hasMore,
+        nextCursor: hasMore && last ? { recordedAt: last.recordedAt, id: last.id } : null,
+    };
+}
 /** Audit trail for one Skill in one worktree, newest first. */
 function listSkillOperationAudit(db, filter) {
-    const limit = filter.limit ?? 100;
-    const rows = (filter.skillId === undefined
-        ? db
-            .prepare(`SELECT ${SELECT_COLUMNS} FROM skill_operations
-             WHERE worktree_id = ? ORDER BY recorded_at DESC, id DESC LIMIT ?`)
-            .all(filter.worktreeId, limit)
-        : db
-            .prepare(`SELECT ${SELECT_COLUMNS} FROM skill_operations
-             WHERE worktree_id = ? AND skill_id = ?
-             ORDER BY recorded_at DESC, id DESC LIMIT ?`)
-            .all(filter.worktreeId, filter.skillId, limit));
-    return rows.map(mapRow);
+    return querySkillOperationAudit(db, {
+        worktreeId: filter.worktreeId,
+        skillId: filter.skillId,
+        limit: filter.limit ?? 100,
+    }).records;
 }

package/dist/server/src/lib/skills/operation-journal.js

@@ -207,6 +207,15 @@ function pruneExpiredSkillOperationJournal(options = {}) {
  *
  * A replay hands back the recorded entry so the caller can answer with the
  * original outcome instead of writing the payload a second time.
+ *
+ * `isReplayable` is how the caller says the recorded outcome is no longer true
+ * of the world (Issue #1552). A derived key is a function of the binding alone,
+ * so a genuinely new request — the install that follows an uninstall — arrives
+ * under the key of the old one; without this it would be answered from an entry
+ * describing a payload that is no longer there. An entry rejected this way is
+ * superseded: it is dropped and a fresh operation is opened, because the request
+ * really is new work. A PREPARING entry is never superseded, whatever the
+ * predicate says: the operation that owns it may still be running.
  */
 function beginSkillOperation(input, options = {}) {
     const bindingHash = computeSkillOperationBindingHash(input.binding);
@@ -216,7 +225,11 @@ function beginSkillOperation(input, options = {}) {
         if (existing.bindingHash !== bindingHash) {
             return { ok: false, reason: 'IDEMPOTENCY_KEY_CONFLICT', entry: existing };
         }
-        return { ok: true, entry: existing, replayed: true };
+        const supersede = existing.state !== 'PREPARING' && input.isReplayable?.(existing) === false;
+        if (!supersede) {
+            return { ok: true, entry: existing, replayed: true };
+        }
+        deleteSkillOperationJournal(idempotencyKey, options);
     }
     const now = options.now ?? Date.now();
     const entry = {